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

  • Artikel

Gilt für:IoT Edge 1.4 checkmark IoT Edge 1.4

Wichtig

IoT Edge Version 1.4 wird unterstützt. Wenn Sie ein früheres Release verwenden, finden Sie weitere Informationen unter Aktualisieren von IoT Edge.

In diesem Tutorial werden die Entwicklung und Bereitstellung Ihres eigenen Codes auf einem IoT Edge-Gerät beschrieben. Mithilfe von Azure IoT Edge-Modulen können Sie Code bereitstellen, der Ihre Geschäftslogik direkt auf Ihren IoT Edge-Geräten implementiert. Unter Schnellstart: Bereitstellen Ihres ersten IoT Edge-Moduls auf einem virtuellen Linux-Gerät haben Sie ein IoT Edge-Gerät erstellt und über Azure Marketplace ein Modul bereitgestellt.

Dieser Artikel enthält Schritte für zwei IoT Edge Entwicklungstools.

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

Verwenden Sie die Schaltfläche für die Toolauswahl am Anfang dieses Artikels, um die Toolversion auszuwählen.

In diesem Tutorial lernen Sie Folgendes:

  • Einrichten Ihres Entwicklungscomputers
  • Verwenden Sie die IoT Edge-Tools zum Erstellen eines neuen Projekts.
  • Erstellen Ihres Projekts als Docker-Container und Speichern in einer Azure-Containerregistrierung
  • Bereitstellen Ihres Codes auf einem IoT Edge-Gerät

Das IoT Edge-Modul, das Sie in diesem Tutorial erstellen, filtert die von Ihrem Gerät generierten Temperaturdaten. Es leitet Nachrichten nur dann an nachgeschaltete Geräte weiter, wenn die Temperatur einen angegebenen Schwellenwert überschreitet. Diese Art der Analyse auf Edge-Ebene trägt zur Verringerung der Datenmenge bei, die an die Cloud übermittelt und dort gespeichert wird.

Voraussetzungen

Ein Entwicklungscomputer:

  • Verwenden Sie Ihren eigenen Computer oder einen virtuellen Computer.
  • Ihr Entwicklungscomputer muss die geschachtelte Virtualisierung zum Ausführen einer Container-Engine unterstützen.
  • Die meisten Betriebssysteme, unter denen eine Container-Engine ausgeführt werden kann, können zum Entwickeln von IoT Edge-Modulen für Linux-Geräte genutzt werden. In diesem Tutorial wird ein Windows-Computer verwendet, aber es wird auf die bekannten Unterschiede unter macOS oder Linux hingewiesen.
  • Installieren Sie Visual Studio Code.
  • Installieren Sie die Azure CLI.

Ein Azure IoT Edge-Gerät:

Cloudressourcen:

  • Einen IoT-Hub in Azure im Tarif „Free“ oder „Standard“.

Wenn Sie kein Azure-Abonnement haben, erstellen Sie ein kostenloses Azure-Konto, bevor Sie beginnen.

Tipp

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

In diesem Tutorial werden die Entwicklungsschritte für Visual Studio Code beschrieben.

Wichtige Begriffe

In diesem Tutorial wird Schritt für Schritt die Entwicklung eines IoT Edge-Moduls beschrieben. Ein IoT Edge-Modul ist ein Container mit ausführbarem Code. Sie können ein oder mehrere Module auf einem IoT Edge-Gerät bereitstellen. Mit Modulen werden bestimmte Aufgaben durchgeführt, z. B. das Erfassen der Daten von Sensoren, das Bereinigen oder Analysieren von Daten oder das Senden von Nachrichten an einen IoT-Hub. Weitere Informationen finden Sie unter Grundlegendes zu Azure IoT Edge-Modulen.

Beim Entwickeln von IoT Edge-Modulen müssen Sie den Unterschied zwischen dem Entwicklungscomputer und dem IoT Edge-Zielgerät verstehen, auf dem das Modul bereitgestellt wird. Der Container, den Sie für Ihren Modulcode erstellen, muss mit dem Betriebssystem (BS) des Zielgeräts übereinstimmen. Am häufigsten kommt beispielsweise ein Szenario vor, bei dem ein Modul auf einem Windows-Computer entwickelt wird, das für ein Linux-Gerät mit IoT Edge bestimmt ist. In diesem Fall wird als Betriebssystem für den Container Linux verwendet. Denken Sie beim Durcharbeiten dieses Tutorials an den Unterschied zwischen dem Betriebssystem des Entwicklungscomputers und dem Betriebssystem des Containers.

Tipp

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

In diesem Tutorial geht es um Geräte, auf denen IoT Edge mit Linux-Containern ausgeführt wird. Sie können Ihr bevorzugtes Betriebssystem verwenden, solange auf Ihrem Entwicklungscomputer Linux-Container ausgeführt werden. Es wird empfohlen, Visual Studio Code für die Entwicklung mit Linux-Containern zu nutzen, und dies ist auch die Vorgehensweise in diesem Tutorial. 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 die unterstützten Entwicklungsszenarien für Linux-Container in Visual Studio Code und Visual Studio aufgeführt.

Visual Studio Code Visual Studio 2019/2022
Architektur des Linux-Geräts 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

Da IoT Edge-Module als Container gepackt werden, benötigen Sie auf Ihrem Entwicklungscomputer ein Docker-kompatibles Containerverwaltungssystem zu deren Erstellung und Verwaltung. Wir empfehlen Docker Desktop für die Entwicklung, da diese beliebte Anwendung zahlreiche Features unterstützt. Mit Docker Desktop unter Windows können Sie zwischen Linux-Containern und Windows-Containern wechseln, damit Sie Module für unterschiedliche Arten von IoT Edge-Geräten entwickeln können.

Verwenden Sie die Docker-Dokumentation für die Installation auf Ihrem Entwicklungscomputer:

  • Install Docker Desktop for Windows (Installieren von Docker Desktop für Windows)

    • Bei der Installation von Docker Desktop für Windows werden Sie gefragt, ob Sie Linux- oder Windows-Container nutzen möchten. Sie können diese Entscheidung jederzeit ändern. In diesem Tutorial verwenden wir Linux-Container, weil unsere Module für Linux-Geräte bestimmt sind. Weitere Informationen finden Sie unter Switch between Windows and Linux containers (Umschalten zwischen Windows- und Linux-Containern).

  • Install Docker Desktop for Mac (Installieren von Docker Desktop für Mac)

  • Unter About Docker CE (Informationen zu Docker CE) finden Sie Informationen zur Installation auf mehreren Linux-Plattformen.

    • Installieren Sie für das Windows-Subsystem für Linux (WSL) Docker Desktop für Windows.

Tools für die Einrichtung

Installieren Sie das Python-basierte Azure IoT Edge Dev Tool, um Ihre IoT Edge-Lösung zu erstellen. Es gibt zwei Optionen:

Wichtig

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

Verwenden Sie die IoT-Erweiterungen für Visual Studio Code zum Entwickeln von IoT Edge-Modulen. Diese Erweiterungen stellen Projektvorlagen bereit, automatisieren die Erstellung des Bereitstellungsmanifests und ermöglichen Ihnen die Überwachung und Verwaltung von IoT Edge-Geräten. 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 Erweiterung Azure IoT Edge.

  2. Installieren Sie die Erweiterung Azure IoT Hub.

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

  4. Wählen Sie in der Befehlspalette den Befehl Azure IoT Hub: IoT Hub auswählen 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 entweder das Symbol in der Aktivitätsleiste auf der linken Seite oder Ansicht>Explorer wählen.

  6. Erweitern Sie unten im Explorer-Abschnitt das reduzierte Menü Azure IoT Hub / Devices (Azure IoT Hub/Geräte). Es sollten die Geräte und IoT Edge-Geräte angezeigt werden, die dem über die Befehlspalette ausgewählten IoT-Hub zugeordnet sind.

Installieren von sprachspezifischen Tools

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

Erstellen einer Containerregistrierung

In diesem Tutorial verwenden Sie die Azure IoT Edge- und Azure IoT Hub-Erweiterungen zum Entwickeln eines Moduls und Erstellen eines Containerimages aus den Dateien. Danach pushen Sie dieses Image in ein Repository, in dem Ihre Images 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-Erweiterung für Visual Studio Code 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 Optionen Ressource erstellen>Container>Container Registry aus.

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

    Feld Wert
    Subscription Wählen Sie ein Abonnement aus der Dropdownliste aus.
    Resource group Verwenden Sie dieselbe Ressourcengruppe für alle Testressourcen, die Sie während der IoT Edge-Schnellstarts und -Tutorials erstellen. Beispielsweise IoTEdgeResources.
    Registrierungsname Geben Sie einen eindeutigen Namen an.
    Location Wählen Sie einen Standort in Ihrer Nähe aus.
    SKU Wählen Sie Basic aus.

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

  4. Wählen Sie auf der Startseite des Azure-Portals im Abschnitt Ressourcen die neue Containerregistrierung aus, um sie zu öffnen.

  5. Wählen Sie im linken Bereich Ihrer Containerregistrierung im Menü unter Einstellungen die Option Zugriffsschlüssel aus.

    Screenshot of the Access Keys menu location.

  6. Aktivieren Sie mit der Umschaltfläche die Option Administratorbenutzer, 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 einem geeigneten Speicherort. 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 verfügen über alle erforderlichen Dateien und den Code zum Bereitstellen eines funktionierenden Moduls für einen IoT Edge-Test. Darüber hinaus dienen Sie Ihnen als Ausgangspunkt zum Anpassen der Vorlage mit Ihrer eigenen Geschäftslogik.

Erstellen einer Projektvorlage

Das IoT Edge-Entwicklungstool vereinfacht die Entwicklung von Azure IoT Edge für Befehle, die durch Umgebungsvariablen gesteuert werden. So beginnen Sie die IoT Edge-Entwicklung mit dem IoT Edge-Entwicklungscontainer und dem IoT Edge-Lösungsgerüst, das ein Standardmodul und alle erforderlichen Konfigurationsdateien enthält.

  1. Erstellen Sie ein Verzeichnis für Ihre Lösung mit einem Pfad Ihrer Wahl. Wechseln Sie zu Ihrem iotedgesolution-Verzeichnis.

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

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

    iotedgedev solution init --template csharp

Das Skript iotedgedev solution 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. Als Erstes erstellen Sie eine Projektmappe, dann generieren Sie das erste Modul in dieser Projektmappe. Jede Projektmappe kann mehrere Module enthalten.

  1. Wählen Sie Ansicht>Befehlspalette aus.
  2. Geben Sie in der Befehlspalette den folgenden Befehl ein, und führen Sie ihn aus: Azure IoT Edge: Neue IoT Edge-Projektmappe ein.
  3. Navigieren Sie zu dem Ordner, in dem Sie die neue Projektmappe 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 Imagerepositorys des Moduls an. Der Visual Studio Code füllt den Modulnamen automatisch mit localhost:5000/<Name Ihres Moduls> auf. Ersetzen Sie ihn durch Ihre eigenen Registrierungsinformationen. Wenn Sie eine lokale Docker-Registrierung zum Testen verwenden, können Sie localhost nutzen. Wenn Sie Azure Container Registry verwenden, nutzen Sie den Anmeldeserver aus den Einstellungen Ihrer Registrierung. Der Anmeldeserver hat die Form <Registrierungsname>.azurecr.io. Ersetzen Sie nur den Teil localhost:5000 der Zeichenfolge, damit das endgültige Ergebnis die folgende Form hat: <Registrierungsname>.azurecr.io/ <Name Ihres Moduls> .

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

Nach der Lösungserstellung befinden sich diese Hauptdateien in der Lösung:

  • Einen .vscode-Ordner mit der Konfigurationsdatei launch.json.

  • Ein Ordner modules, der Unterordner für jedes Modul enthält. Innerhalb des Unterordners für die einzelnen Module steuert die Datei module.json, wie Module erstellt und bereitgestellt werden.

  • Eine .env-Datei, in der Ihre Umgebungsvariablen aufgeführt werden. Die Umgebungsvariable für die Containerregistrierung ist standardmäßig localhost:5000.

  • In zwei Modulbereitstellungsdateien namens deployment.template.json und deployment.debug.template.json werden die Module aufgelistet, 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

    Welche Module genau installiert werden, kann je nach der ausgewählten Sprache variieren.

Festlegen der IoT Edge-Runtimeversion

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

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

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

    "systemModules": {
    "edgeAgent": {

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

    "edgeHub": {

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

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 per Pullvorgang auf das IoT Edge-Gerät zu übertragen.

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. Sie finden diese Werte im Azure-Portal im Menü Einstellungen>Zugriffsschlüssel für Ihre Containerregistrierung.

  2. Öffnen Sie in Ihrer Modulprojektmappe die .env-Datei.

  3. Fügen Sie die Werte für Benutzername und Kennwort hinzu, die Sie aus der 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 an der .env-Datei.

Hinweis

In diesem Tutorial werden Administratoranmeldeinformationen für Azure Container Registry 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 die Containerregistrierung.

Zielarchitektur

Sie müssen bei jeder Lösung auswählen, welche Architektur Sie als Ziel verwenden möchten, weil sich dies darauf auswirkt, wie der Container erstellt und ausgeführt wird. Der Standardwert ist „Linux AMD64“. In diesem Tutorial wird eine Ubuntu-VM als IoT Edge-Gerät verwendet. Der Standardwert amd64 wird beibehalten.

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: Set Default Target Platform for Edge Solution (Standardzielplattform für Edge-Projektmappe festlegen), oder wählen Sie das Verknüpfungssymbol in der Seitenleiste 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 Modul SimulatedTemperatureSensor an den IoT-Hub weiterleitet. Dieses Beispielmodul empfängt Nachrichten und leitet sie dann weiter. Mit der Pipelinefunktionalität wird ein wichtiges Konzept von IoT Edge veranschaulicht. Hierbei geht es darum, wie Module miteinander kommunizieren.

Für jedes Modul können im Code mehrere Warteschlangen für die Eingabe und Ausgabe deklariert werden. Der IoT Edge-Hub, der auf dem Gerät ausgeführt wird, leitet Nachrichten aus der Ausgabe eines Moduls an die Eingabe mindestens eines anderen Moduls weiter. Der spezifische Code zum Deklarieren von Ein- und Ausgaben variiert je nach Sprache, aber das Konzept ist modulübergreifend identisch. Weitere Informationen zum Routing zwischen Modulen finden Sie unter Deklarieren von Routen.

Der in der Projektvorlage enthaltene C#-Beispielcode 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 Namespace filtermodule drei using-Anweisungen für Typen hinzu, die im weiteren Verlauf 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 Klasse ModuleBackgroundService die Variable temperatureThreshold hinzu. Diese Variable legt den Wert fest, den die gemessene Temperatur übersteigen muss, damit die Daten an die IoT Hub-Instanz 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 Funktion ExecuteAsync. Diese Funktion erstellt und konfiguriert ein ModuleClient-Objekt, das es dem Modul ermöglicht, eine Verbindung mit der lokalen Azure IoT Edge-Runtime zum Senden und Empfangen von Nachrichten herzustellen. Nach dem Erstellen von ModuleClient liest der Code den Wert temperatureThreshold aus den gewünschten Eigenschaften des Modulzwillings. Der Code registriert einen Rückruf, um über einen Endpunkt namens input1 Nachrichten von einem IoT Edge-Hub zu empfangen.

    Ersetzen Sie den Aufruf der Methode ProcessMessageAsync durch einen neuen, der den Namen des Endpunkts und die Methode aktualisiert, die beim Eingang der Eingabe aufgerufen wird. Fügen Sie außerdem eine Methode vom Typ SetDesiredPropertyUpdateCallbackAsync hinzu, um die gewünschten Eigenschaften aktualisieren zu können. Ersetzen Sie dazu die letzte Zeile der Methode ExecuteAsync durch den folgenden Code:

    // 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 Klasse ModuleBackgroundService die Methode onDesiredPropertiesUpdate hinzu. Diese Methode empfängt Aktualisierungen der gewünschten Eigenschaften aus dem Modulzwilling 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 Methode FilterMessages 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. Sie fügt der Nachricht außerdem die MessageType-Eigenschaft hinzu, deren 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 Datei ModuleBackgroundService.cs.

  9. Öffnen Sie im Visual Studio Code-Explorer die Datei deployment.template.json im Arbeitsbereich für Ihre IoT Edge-Lösung.

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

    Navigieren Sie im Modulzwilling $edgeHub zum Abschnitt Routen. Aktualisieren Sie die Route sensorTofiltermodule, und ersetzen Sie input1 durch inputFromSensor:

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

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

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

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

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 Bereitstellungsmanifestdatei deployment.template.json. Im Bereitstellungsmanifest werden die Module beschrieben, die auf dem IoT Edge-Zielgerä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 Erstellungsoptionen für Container für IoT Edge-Module.

Wenn Sie Azure Container Registry zum Speichern Ihres Modulimages verwenden, 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 die Adresse für Ihren Anmeldeserver 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\"}]}}}"

Beispielsweise sollte die Konfiguration filtermodule ungefähr wie folgt aussehen:

"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 in Visual Studio Code integrierte Terminal, indem Sie Terminal>Neues Terminal auswählen.

Verwenden Sie den Befehl dotnet publish, um das Containerimage für Linux und die amd64-Architektur zu erstellen. Ändern Sie das Verzeichnis in das Zerzeichnis filtermodule In Ihrem Projekt und führen Sie den Befehl dotnet publish aus.

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

Derzeit ist die Toolvorlage iotedgedev auf .NET 7.0 ausgerichtet. Wenn Sie eine andere Version von .NET nutzen möchten, können Sie die Datei filtermodule.csproj bearbeiten und die Werte TargetFramework und PackageReference ändern. Um .NET 8.0 als Ziel festzulegen, sollte die Datei filtermodule.csproj zum Beispiel 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 login-Referenz.

  2. Melden Sie sich bei Azure Container Registry an. Sie müssen die Azure CLI installieren, um den Befehl az verwenden zu können. Mit diesem Befehl werden Ihr Benutzername und Kennwort in Ihrer Containerregistrierung unter Einstellungen>Zugriffsschlüssel abgefragt.

    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 die Azure Container Registry-Instanz myacr.azurecr.io verwenden und Ihr Image filtermodule:0.0.1-amd64 ist, aktualisieren Sie die filtermodule-Konfiguration wie folgt:

"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 Datei deployment.template.json, und klicken Sie anschließend auf Build and Push IoT Edge solution (IoT Edge-Projektmappe erstellen und übertragen).

Der Befehl zum Erstellen und Übertragen per Push startet drei Vorgänge. Zuerst erstellt er in der Projektmappe einen neuen Ordner mit dem Namen config. Darin ist das vollständige Bereitstellungsmanifest gespeichert, das aus Informationen in der Bereitstellungsvorlage und anderen Projektmappendateien 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 Datei deployment.amd64.json im neu erstellten Ordner „config“. 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 Bereich registryCredentials enthält Ihren Benutzernamen und das zugehörige Kennwort für die Registrierung aus der .env-Datei. filtermodule enthält das vollständige Image-Repository mit dem Namen, der Version und dem Architekturtag aus der module.json-Datei.

  1. Öffnen Sie die Datei module.json 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 an 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 Datei deployment.template.json, und wählen Sie erneut die Option Build and Push IoT Edge solution (IoT Edge-Projektmappe erstellen und übertragen).

Öffnen Sie erneut die Datei deployment.amd64.json. 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 Image filtermodule verweist jetzt auf Version 0.0.2 des Containers.

Sie können noch genauer überprüfen, was mit dem Befehl zum Erstellen und Pushen durchgeführt wurde, indem Sie im Azure-Portal zu Ihrer Containerregistrierung navigieren.

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

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

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 zur Überprüfung die Datei module.json im Ordner filtermodule. Der Repositorywert sollte das Format <Registrierungsname>.azurecr.io/filtermodule haben.
  • Wenn Sie für Ihr Modul einen anderen Namen als filtermodule verwendet haben: Wurde dieser Name in der gesamten Lösung einheitlich verwendet?
  • Entsprechen die auf Ihrem Computer ausgeführten Containertypen den von Ihnen erstellten Containertypen? Dieses Tutorial ist für Linux-IoT Edge-Geräte bestimmt. In Visual Studio Code sollte in der Seitenleiste also amd64 oder arm32v7 angezeigt werden, und für Docker Desktop sollten Linux-Container ausgeführt werden.

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 zum Bereitstellen der Module für den Azure IoT Hub. Verwenden Sie beispielsweise den folgenden Befehl, um die in der Datei deployment.template.json definierten Module für den IoT Hub my-iot-hub und das IoT Edge-Gerät my-device bereitzustellen. Ersetzen Sie die Werte für hub-name, device-id und login der IoT Hub-Verbindungszeichenfolge durch Ihre eigenen.

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

Sie finden Ihre IoT Hub-Verbindungszeichenfolge, einschließlich des freigegebenen Zugriffsschlüssels, im Azure-Portal. Wechseln Sie in Ihrem IoT Hub zu >Sicherheitseinstellungen>Freigegebene Zugriffsrichtlinien>iothubowner.

  1. Erweitern Sie im Visual Studio Code-Explorer im Abschnitt Azure IoT Hub den Bereich Geräte, um Ihre IoT-Geräteliste anzuzeigen.

  2. Klicken Sie mit der rechten Maustaste auf das IoT Edge-Gerät, auf dem Sie die Bereitstellung durchführen möchten, und wählen Sie dann Create Deployment for Single Device (Bereitstellung für einzelnes Gerät erstellen).

  3. Navigieren Sie im Datei-Explorer zum Ordner config, und wählen Sie die Datei deployment.amd64.json 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 ein Linux ARM32-Gerät als Ziel verwenden, ist der Name des Bereitstellungsmanifests deployment.arm32v7.json.

  4. Erweitern Sie unter Ihrem Gerät den Bereich Module, um eine Liste mit bereitgestellten und ausgeführten Modulen anzuzeigen. Klicken Sie auf die Schaltfläche Aktualisieren. Die neuen Module tempSensor und filtermodule sollten auf Ihrem Gerät ausgeführt werden.

    Es dauert ggf. einige Minuten, bis die Module gestartet werden. Die IoT Edge-Runtime muss das neue Bereitstellungsmanifest empfangen, die Modulimages per Pullvorgang aus der Containerruntime abrufen und dann jedes neue Modul starten.

Anzeigen von Nachrichten vom Gerät

Der Code des Beispielmoduls empfängt Nachrichten über die zugehörige Eingabewarteschlange und leitet diese an die Ausgabewarteschlange weiter. Im Bereitstellungsmanifest wurden Routen deklariert, über die Nachrichten von tempSensor an filtermodule und von filtermodule dann an IoT Hub übergeben wurden. Mithilfe der Azure IoT Edge- und Azure IoT Hub-Erweiterungen können Sie Nachrichten anzeigen, während sie von Ihren einzelnen Geräten bei IoT Hub eingehen.

  1. Klicken Sie im Visual Studio Code-Explorer mit der rechten Maustaste auf das IoT Edge-Gerät, das Sie überwachen möchten, und wählen Sie dann die Option Start Monitoring Built-in Event Endpoint (Überwachung des integrierten Ereignisendpunkts starten) aus.

  2. Im Ausgabefenster von Visual Studio Code können Sie anschließend verfolgen, wie die Nachrichten auf Ihrem IoT-Hub eingehen.

    Screenshot showing where to view incoming device to cloud messages.

Anzeigen von Änderungen auf dem Gerät

Wenn Sie die Vorgänge direkt auf dem Gerät verfolgen möchten, können Sie die Befehle in diesem Abschnitt verwenden, um die IoT Edge-Runtime und die Module zu untersuchen, die auf Ihrem Gerät ausgeführt werden.

Die Befehle in diesem Abschnitt gelten für Ihr IoT Edge-Gerät und 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. Navigieren Sie in Azure zur Übersichtsseite des virtuellen Computers, und wählen Sie die Option Verbinden, um auf die Secure Shell-Verbindung zuzugreifen.

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

    iotedge list

    Es sollten vier Module angezeigt werden: die beiden IoT Edge-Runtime-Module, tempSensor und filtermodule. Alle vier sollten als ausgeführt aufgeführt werden.

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

    iotedge logs <module name>

    Bei IoT Edge-Modulen wird die Groß-/Kleinschreibung beachtet.

    In den Protokollen von tempSensor und filtermodule sollten die verarbeiteten Nachrichten angezeigt werden. Das Modul edgeAgent ist für das Starten der anderen Module zuständig. Die Protokolle dieses Moduls enthalten also Informationen zur Implementierung des Bereitstellungsmanifests. Wenn Sie feststellen, dass ein Modul nicht aufgeführt ist oder nicht ausgeführt wird, weisen die edgeAgent-Protokolle wahrscheinlich die Fehler auf. Das Modul „edgeHub“ ist für die Kommunikation zwischen den Modulen und IoT Hub zuständig. Wenn die Module betriebsbereit sind und ausgeführt werden, aber die Nachrichten nicht auf Ihrem IoT-Hub ankommen, sind die Fehler wahrscheinlich in den Protokollen von edgeHub enthalten.

Bereinigen von Ressourcen

Falls Sie mit dem nächsten empfohlenen Artikel fortfahren möchten, können Sie die erstellten Ressourcen und Konfigurationen beibehalten und wiederverwenden. Sie können auch dasselbe IoT Edge-Gerät als Testgerät weiter nutzen.

Andernfalls können Sie die in diesem Artikel verwendeten lokalen Konfigurationen und die Azure-Ressourcen löschen, um Kosten 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 bereits vorhandenen Ressourcengruppe erstellt haben, die Ressourcen enthält, die Sie behalten möchten, löschen Sie nicht die Ressourcengruppe, sondern nur die IoT-Hub-Ressource.

So löschen Sie die Ressourcen:

  1. Melden Sie sich beim Azure-Portal an, und wählen Sie anschließend 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 in Ihrer Ressourcengruppe enthalten sind. Wenn Sie alle löschen möchten, klicken Sie auf Ressourcengruppe löschen. Wenn Sie nur einige Ressourcen löschen möchten, klicken Sie auf die jeweiligen Ressourcen, um sie einzeln zu löschen.

Nächste Schritte

In diesem Tutorial haben Sie Visual Studio Code auf Ihrem Entwicklungscomputer eingerichtet und Ihr erstes IoT Edge-Modul bereitgestellt, das Code zum Filtern von Rohdaten enthält, die von Ihrem IoT Edge-Gerät generiert wurden.

Sie können die nächsten Tutorials durcharbeiten, um zu erfahren, wie Ihnen Azure IoT Edge bei der Bereitstellung von Azure-Clouddiensten helfen kann, um Daten auf Edge-Ebene zu verarbeiten und zu analysieren.

Debuggen von Azure IoT Edge-ModulenFunktionenStream AnalyticsCustom Vision-Dienst