Tutorial: Entwickeln von C#-IoT Edge-Modulen mit Windows-Containern

Artikel
08/03/2020

Gilt für: IoT Edge 1.1

Wichtig

IoT Edge 1.1: Datum für das Supportende war der 13. Dezember 2022. Informationen zur Unterstützung für dieses Produkt, diesen Dienst, diese Technologie oder diese API finden Sie in der Microsoft Lifecycle-Richtlinie. Weitere Informationen zum Aktualisieren auf die neueste Version von IoT Edge finden Sie unter Update IoT Edge.

In diesem Artikel wird veranschaulicht, wie Sie Visual Studio zum Entwickeln von C#-Code und anschließenden Bereitstellen auf einem Windows-Gerät verwenden, auf dem Azure IoT Edge ausgeführt wird.

Hinweis

IoT Edge 1.1 LTS ist der letzte Releasekanal, der Windows-Container unterstützt. Ab Version 1.2 werden Windows-Container nicht mehr unterstützt. Wenn Sie IoT Edge auf Windows-Geräten ausführen möchten, sollten Sie IoT Edge für Linux unter Windows verwenden oder dorthin wechseln.

Mithilfe von Azure IoT Edge-Modulen können Sie Code bereitstellen, mit dem Ihre Geschäftslogik direkt auf Ihren IoT Edge-Geräten implementiert wird. In diesem Tutorial wird beschrieben, wie Sie ein IoT Edge-Modul, mit dem Sensordaten gefiltert werden, erstellen und bereitstellen.

In diesem Tutorial lernen Sie Folgendes:

Verwenden von Visual Studio zum Erstellen eines IoT Edge-Moduls auf der Grundlage des C# SDK
Erstellen und Veröffentlichen eines Docker-Images in Ihrer Registrierung unter Verwendung von Visual Studio und Docker
Bereitstellen des Moduls auf Ihrem IoT Edge-Gerät
Anzeigen generierter Daten

Das IoT Edge-Modul, das Sie in diesem Tutorial erstellen, filtert die von Ihrem Gerät generierten Temperaturdaten. Vom Modul werden nur dann Nachrichten in Upstream-Richtung gesendet, wenn die Temperatur einen bestimmten 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.

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

Voraussetzungen

In diesem Tutorial wird veranschaulicht, wie Sie ein Modul in C# mit Visual Studio 2019 entwickeln und dann auf einem Windows-Gerät bereitstellen. Wenn Sie Module unter Verwendung von Linux-Containern entwickeln, lesen Sie stattdessen die Informationen unter Tutorial: Entwickeln eines C#-IoT Edge-Moduls für Linux-Geräte.

Informieren Sie sich anhand der folgenden Tabelle über Ihre Optionen zum Entwickeln und Bereitstellen von C#-Modulen mit Windows-Containern:

C#	Visual Studio Code	Visual Studio 2017 und 2019
Windows AMD64-Entwicklung
Windows AMD64-Debugging

Richten Sie vor dem Durcharbeiten dieses Tutorials zunächst Ihre Entwicklungsumgebung ein, indem Sie die Anleitung im Tutorial Entwickeln von IoT Edge-Modulen mit Windows-Containern befolgen. Nach Abschluss dieses Vorgangs verfügt Ihre Umgebung über die folgenden erforderlichen Komponenten:

Einen IoT-Hub in Azure im Tarif „Free“ oder „Standard“.
Ein Windows-Gerät, auf dem Azure IoT Edge ausgeführt wird
Eine Containerregistrierung, z. B. Azure Container Registry
Visual Studio 2019 mit der konfigurierten Erweiterung Azure IoT Edge Tools
Docker Desktop, zur Ausführung von Windows-Containern konfiguriert.

Tipp

Wenn Sie Visual Studio 2017 (ab Version 15.7) verwenden, müssen Sie Azure IoT Edge Tools für Visual Studio 2017 aus Visual Studio Marketplace herunterladen und installieren.

Erstellen eines Modulprojekts

In diesem Abschnitt erstellen Sie ein IoT Edge-Modulprojekt, indem Sie Visual Studio und die Erweiterung „Azure IoT Edge Tools“ verwenden. Nachdem Sie eine Projektvorlage erstellt haben, fügen Sie ihr neuen Code hinzu, damit das Modul Nachrichten aufgrund der darin gemeldeten Eigenschaften herausfiltern kann.

Erstellen eines neuen Projekts

Mit Azure IoT Edge Tools werden Projektvorlagen für alle unterstützten IoT Edge-Modulsprachen in Visual Studio bereitgestellt. Diese Vorlagen verfügen über alle Dateien und Codeelemente, die Sie zum Bereitstellen eines funktionierenden Moduls zum Testen von IoT Edge benötigen. Sie können Ihnen auch als Ausgangspunkt für die Anpassung mit Ihrer eigenen Geschäftslogik dienen.

Öffnen Sie Visual Studio 2019, und wählen Sie Neues Projekt erstellen aus.
Suchen Sie im Bereich Neues Projekt erstellen nach IoT Edge, und wählen Sie dann in der Ergebnisliste das Projekt Azure IoT Edge (Windows amd64) aus.
Wählen Sie Weiter aus.

Der Bereich Neues Projekt konfigurieren wird geöffnet.
Geben Sie dem Projekt und der Projektmappe im Bereich Neues Projekt konfigurieren aussagekräftigere Namen, z. B. CSharpTutorialApp.
Wählen Sie Create (Erstellen), um das Projekt zu erstellen.

Der Bereich Modul hinzufügen wird geöffnet.
Gehen Sie auf der Seite Neues Projekt konfigurieren wie folgt vor:

a. Wählen Sie im Bereich auf der linken Seite die Vorlage C#-Modul aus.
b. Geben Sie im Feld Modulname den Namen CSharpModule ein.
c. Ersetzen Sie im Feld Repository-URL den Text localhost:5000 durch den Wert für den Anmeldeserver aus Ihrer Azure-Containerregistrierung, indem Sie das folgende Format verwenden: <registry name>.azurecr.io/csharpmodule

Hinweis

Ein Imagerepository enthält den Namen Ihrer Containerregistrierung und den Namen Ihres Containerimages. Für Ihr Containerimage ist der Wert des Modulprojektnamens bereits vorhanden. Den Anmeldeserver können Sie im Azure-Portal auf der Übersichtsseite Ihrer Containerregistrierung ermitteln.
Wählen Sie Hinzufügen aus, um das Projekt zu erstellen.

Hinzufügen von Registrierungsanmeldeinformationen

Das Bereitstellungsmanifest gibt die Anmeldeinformationen für Ihre Containerregistrierung an die IoT Edge-Runtime weiter. Die Runtime benötigt diese Anmeldeinformationen, um Ihre privaten Images per Pull auf das IoT Edge-Gerät zu übertragen. Verwenden Sie die Anmeldeinformationen aus dem Abschnitt Zugriffsschlüssel Ihrer Azure-Containerregistrierung.

Öffnen Sie im Projektmappen-Explorer von Visual Studio die Datei deployment.template.json.
Suchen Sie unter den gewünschten Eigenschaften von „$edgeAgent“ nach der registryCredentials-Eigenschaft. Die Registrierungsadresse der Eigenschaft sollte automatisch mit den Informationen eingefügt werden, die Sie beim Erstellen des Projekts angegeben haben. Die Felder für Benutzername und Kennwort sollten Variablennamen enthalten. Beispiel:
```
"registryCredentials": {
  "<registry name>": {
    "username": "$CONTAINER_REGISTRY_USERNAME_<registry name>",
    "password": "$CONTAINER_REGISTRY_PASSWORD_<registry name>",
    "address": "<registry name>.azurecr.io"
  }
}
```
Öffnen Sie die Umgebungsdatei (ENV) in Ihrer Modullösung. Da die Datei im Projektmappen-Explorer standardmäßig ausgeblendet ist, müssen Sie unter Umständen die Schaltfläche Alle Dateien anzeigen auswählen, um sie anzuzeigen. Die ENV-Datei muss die gleichen Variablen für Benutzername und Kennwort wie die Datei deployment.template.json enthalten.
Fügen Sie die Werte für Benutzername und Kennwort aus Ihrer Azure-Containerregistrierung hinzu.
Speichern Sie Ihre Änderungen an der ENV-Datei.

Aktualisieren des Moduls mit benutzerdefiniertem Code

Der Standardmodulcode empfängt Nachrichten in einer Eingabewarteschlange und leitet sie über eine Ausgabewarteschlange weiter. Fügen Sie zusätzlichen Code hinzu, damit das Modul die Nachrichten im Edge-Bereich verarbeitet, bevor es sie an Ihren IoT-Hub weiterleitet. Aktualisieren Sie das Modul, damit es die Temperaturdaten in jeder Nachricht analysiert und die Nachricht nur dann an den IoT-Hub sendet, wenn die Temperatur einen bestimmten Schwellenwert überschreitet.

Wählen Sie in Visual Studio CSharpModule>Program.cs aus.

Fügen Sie oben im Namespace CSharpModule 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

Fügen Sie der Klasse Program nach der Indikatorvariablen die Variable temperatureThreshold hinzu. Die Variable „temperatureThreshold“ 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;
```

Fügen Sie der Klasse Program nach den Variablendeklarationen 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;}
}

Suchen Sie nach der Init-Methode. Diese Methode 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. Der Code registriert außerdem einen Rückruf, um über den Endpunkt input1 Nachrichten von einem IoT Edge-Hub zu empfangen.

Ersetzen Sie die gesamte Init-Methode durch den folgenden Code:
```
static async Task Init()
{
    AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only);
    ITransportSettings[] settings = { amqpSetting };

    // Open a connection to the Edge runtime.
    ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
    await ioTHubModuleClient.OpenAsync();
    Console.WriteLine("IoT Hub module client initialized.");

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

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

    // Register a callback for messages that are received by the module.
    await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterMessages, ioTHubModuleClient);
}
```
Mit dieser aktualisierten Init-Methode wird auch weiterhin per „ModuleClient“ die Verbindung mit der IoT Edge-Runtime hergestellt, aber sie verfügt über neue Funktionen. Sie liest die gewünschten Eigenschaften des Modulzwillings zum Abrufen des Werts temperatureThreshold. Anschließend wird damit ein Rückruf erstellt, der auf alle zukünftigen Aktualisierungen der gewünschten Eigenschaften des Modulzwillings lauscht. Mit diesem Rückruf können Sie den Temperaturschwellenwert im Modulzwilling remote aktualisieren, und die Änderungen werden in das Modul integriert.

Die aktualisierte Init-Methode ändert darüber hinaus die vorhandene Methode SetInputMessageHandlerAsync. Im Beispielcode werden eingehende Nachrichten für input1 mit der Funktion PipeMessage verarbeitet. Der Code soll jedoch so geändert werden, dass stattdessen die Funktion FilterMessages verwendet wird, die wir in den nächsten Schritten erstellen.

Fügen Sie der Klasse Program die neue 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;
}

Entfernen Sie die Beispielmethode PipeMessage, und ersetzen Sie sie durch die neue Methode FilterMessages. Diese Methode wird aufgerufen, wenn das Modul eine Nachricht vom IoT Edge-Hub empfängt. Sie filtert Nachrichten heraus, mit denen Temperaturen gemeldet werden, die unter dem über den Modulzwilling festgelegten Temperaturschwellenwert liegen. Darüber hinaus fügt die Methode der Nachricht außerdem die MessageType-Eigenschaft hinzu, deren Wert auf Alert festgelegt ist.

static 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;
    }
}

Speichern Sie die Datei Program.cs.
Öffnen Sie die Datei deployment.template.json in Ihrer IoT Edge-Projektmappe. Mithilfe dieser Datei wird dem IoT Edge-Agent mitgeteilt, welche Module bereitgestellt werden sollen, und dem IoT Edge-Hub wird mitgeteilt, wie die Nachrichtenweiterleitung dazwischen durchgeführt werden soll. Die Module für die Bereitstellung lauten hier SimulatedTemperatureSensor und CSharpModule.
Fügen Sie dem Bereitstellungsmanifest den Modulzwilling CSharpModule hinzu. Fügen Sie am Ende des Abschnitts modulesContent nach dem Modulzwilling $edgeHub den folgenden JSON-Inhalt ein:
```
   "CSharpModule": {
       "properties.desired":{
           "TemperatureThreshold":25
       }
   }
```
Speichern Sie die Datei deployment.template.json.

Erstellen und Pushen Ihres Moduls

Im obigen Abschnitt haben Sie eine IoT Edge-Projektmappe erstellt und CSharpModule Code hinzugefügt, mit dem Nachrichten herausgefiltert werden, deren gemeldete Computertemperatur unter dem zulässigen Schwellenwert liegt. Nun müssen Sie die Projektmappe als Containerimage erstellen und per Push an die Containerregistrierung übertragen.

Verwenden Sie den folgenden Befehl, um sich auf Ihrem Entwicklungscomputer bei Docker anzumelden. Verwenden Sie den Benutzernamen, das Kennwort und den Anmeldeserver aus Ihrer Azure-Containerregistrierung. Diese Werte finden Sie im Azure-Portal im Abschnitt Zugriffsschlüssel Ihrer Registrierung.
```
docker login -u <ACR username> -p <ACR password> <ACR login server>
```
Unter Umständen wird eine Sicherheitswarnung angezeigt, in der die Verwendung von --password-stdin empfohlen wird. Dies ist zwar eine empfohlene bewährte Methode für Produktionsszenarien, aber sie ist nicht Gegenstand dieses Tutorials. Weitere Informationen finden Sie in der docker login-Referenz.

Erstellen und Pushen

Klicken Sie im Projektmappen-Explorer von Visual Studio mit der rechten Maustaste auf den Namen des Projekts, das Sie erstellen möchten. Der Standardname lautet AzureIotEdgeApp1. Da Sie ein Windows-Modul erstellen, sollte die Erweiterung Windows.Amd64 lauten.
Wählen Sie Build and Push IoT Edge Modules (IoT Edge-Module erstellen und pushen) aus.

Mit dem Befehl zum Erstellen und Übertragen per Push werden drei Vorgänge gestartet:
- Zuerst wird in der Projektmappe ein neuer Ordner mit dem Namen config erstellt, der das vollständige Bereitstellungsmanifest enthält. Es basiert auf den Informationen der Bereitstellungsvorlage und anderer Projektmappendateien.
- Anschließend wird docker build zum Erstellen des Containerimages ausgeführt, das auf der entsprechenden Dockerfile für Ihre Zielarchitektur basiert.
- Abschließend wird dann docker push ausgeführt, um das Imagerepository per Push in Ihre Containerregistrierung zu übertragen.
Dieser Vorgang kann beim ersten Mal ggf. einige Minuten dauern, aber die nächste Ausführung der Befehle geht dann schon schneller.

Bereitstellen von Modulen auf dem Gerät

Verwenden Sie Visual Studio Cloud-Explorer und die Erweiterung „Azure IoT Edge Tools“ zum Bereitstellen des Modulprojekts auf Ihrem IoT Edge-Gerät. Sie haben schon ein Bereitstellungsmanifest für Ihr Szenario vorbereitet: die Datei deployment.windows-amd64.json im Ordner config. Nun müssen Sie nur noch ein Gerät auswählen, um die Bereitstellung zu empfangen.

Sorgen Sie dafür, dass Ihr IoT Edge-Gerät ordnungsgemäß ausgeführt wird.

Erweitern Sie im Cloud-Explorer von Visual Studio die Ressourcen, um Ihre Liste mit den IoT-Geräten anzuzeigen.
Klicken Sie mit der rechten Maustaste auf den Namen des IoT Edge-Geräts, das die Bereitstellung erhalten soll.
Wählen Sie Bereitstellung erstellen aus.
Wählen Sie im Datei-Explorer von Visual Studio im Ordner config Ihrer Projektmappe die Datei deployment.windows-amd64.json aus.
Aktualisieren Sie den Cloud-Explorer, um die bereitgestellten Module anzuzeigen, die unter Ihrem Gerät aufgeführt sind.

Anzeigen generierter Daten

Nachdem Sie das Bereitstellungsmanifest auf Ihr IoT Edge-Gerät angewendet haben, erfasst die IoT Edge-Runtime auf dem Gerät die neuen Bereitstellungsinformationen und verwendet sie bei der Ausführung. Alle auf dem Gerät ausgeführten Module, die nicht im Bereitstellungsmanifest enthalten sind, werden beendet. Alle Module, die auf dem Gerät fehlen, werden gestartet.

Mit der Erweiterung „IoT Edge Tools“ können Sie die auf Ihrem IoT-Hub eingehenden Nachrichten anzeigen.

Wählen Sie in Visual Studio Cloud-Explorer den Namen Ihres IoT Edge-Geräts aus.
Wählen Sie in der Liste Aktionen die Option Start Monitoring Built-in Event Endpoint (Überwachung des integrierten Ereignisendpunkts starten) aus.
Zeigen Sie die Nachrichten an, die auf Ihrem IoT-Hub eintreffen. Unter Umständen dauert es eine Weile, bis die Nachrichten eingehen, weil das IoT Edge-Gerät erst seine neue Bereitstellung empfangen und alle Module starten muss. Die Änderungen am CSharpModule-Code müssen warten, bis die Computertemperatur 25 Grad erreicht hat. Erst dann können die Nachrichten gesendet werden. Außerdem wird mit dem Code allen Nachrichten, für die dieser Temperaturschwellenwert erreicht wird, der Nachrichtentyp Alert (Warnung) hinzugefügt.

Bearbeiten des Modulzwillings

Sie haben den Modulzwilling „CSharpModule“ verwendet, um den Temperaturschwellenwert auf 25 Grad festzulegen. Mithilfe des Modulzwillings können Sie die Funktionalität ändern, ohne den Modulcode aktualisieren zu müssen.

Öffnen Sie in Visual Studio die Datei deployment.windows-amd64.json.

Öffnen Sie nicht die Datei deployment.template. Falls das Bereitstellungsmanifest nicht in der Datei config im Projektmappen-Explorer angezeigt wird, wählen Sie in der Symbolleiste des Projektmappen-Explorers das Symbol Alle Dateien anzeigen aus.
Suchen Sie nach dem Zwilling „CSharpModule“, und ändern Sie den Wert des Parameters temperatureThreshold in eine neue Temperatur, die fünf bis zehn Grad über der zuletzt gemeldeten Temperatur liegt.
Speichern Sie die Datei deployment.windows-amd64.json.
Befolgen Sie erneut die Bereitstellungsanleitung, um das aktualisierte Bereitstellungsmanifest auf Ihr Gerät anzuwenden.
Überwachen Sie die eingehenden D2C-Nachrichten (Device-to-Cloud, Gerät-zu-Cloud). Die Nachrichten sollten so lange gestoppt werden, bis der neue Temperaturschwellenwert erreicht wird.

Bereinigen von Ressourcen

Falls Sie mit dem nächsten empfohlenen Artikel fortfahren möchten, können Sie die in diesem Tutorial 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 hier verwendeten lokalen Konfigurationen und die Azure-Ressourcen löschen, um das Anfallen von 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:

Melden Sie sich beim Azure-Portal an, und wählen Sie anschließend Ressourcengruppen aus.
Wählen Sie den Namen der Ressourcengruppe aus, die Ihre IoT Edge-Testressourcen enthält.
Ü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 ein IoT Edge-Modul mit Code zum Filtern von Rohdaten erstellt, die von Ihrem IoT Edge-Gerät generiert werden.

Arbeiten Sie die nächsten Tutorials durch, 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.

Azure Functions Azure Stream Analytics Azure Machine Learning Custom Vision-Dienst