Freigeben über

Erstellen von WASM-Modulen für Datenflüsse in VS Code

Das benutzerdefinierte WebAssembly(WASM)-Datenverarbeitungsfeature in Azure IoT Operations ermöglicht die Echtzeit-Telemetriedatenverarbeitung innerhalb Ihres Azure IoT Operations-Clusters. Durch die Bereitstellung von benutzerdefinierten WASM-Modulen können Sie Datentransformationen als Teil Ihres Datenflussdiagramms oder HTTP/REST-Connectors definieren und ausführen.

In diesem Artikel wird beschrieben, wie Sie die Azure IoT Operations Data Flow VS Code-Erweiterung verwenden, um Ihre WASM-Module lokal zu entwickeln, zu testen und zu debuggen, bevor Sie sie in Ihrem Azure IoT Operations-Cluster bereitstellen. Hier erfahren Sie, wie Sie:

  • Führen Sie eine Diagrammanwendung lokal aus, indem Sie ein vordefiniertes Diagramm mit Beispieldaten ausführen, um den grundlegenden Workflow zu verstehen.
  • Erstellen Sie benutzerdefinierte WASM-Module, indem Sie neue Operatoren in Python und Rust mit Karten- und Filterfunktionen erstellen.
  • Verwenden Sie den Zustandsspeicher, um den Zustand über die Nachrichtenverarbeitung hinweg beizubehalten.
  • Verwenden Sie die Schemaregistrierungsüberprüfung, um Nachrichtenformate mithilfe von JSON-Schemas vor der Verarbeitung zu überprüfen.
  • Debuggen Sie WASM-Module mit Hilfe von Haltepunkten und schrittweisem Debugging für die lokale Entwicklung.

Die Erweiterung wird auf den folgenden Plattformen unterstützt:

  • Linux
  • Windows-Subsystem für Linux (WSL)
  • Fenster

Weitere Informationen zu Graphen und WASM in Azure IoT Operations finden Sie unter:

Voraussetzungen

Entwicklungsumgebung:

Docker Images:

docker pull mcr.microsoft.com/azureiotoperations/processor-app:1.1.4
docker tag mcr.microsoft.com/azureiotoperations/processor-app:1.1.4 host-app

docker pull mcr.microsoft.com/azureiotoperations/devx-runtime:0.1.8
docker tag mcr.microsoft.com/azureiotoperations/devx-runtime:0.1.8 devx

docker pull mcr.microsoft.com/azureiotoperations/statestore-cli:0.0.2
docker tag mcr.microsoft.com/azureiotoperations/statestore-cli:0.0.2 statestore-cli

docker pull eclipse-mosquitto

Verwenden der VS Code-Erweiterung zum lokalen Ausführen einer Graph-Anwendung

In diesem Beispiel wird ein Beispielarbeitsbereich verwendet, der alle erforderlichen Ressourcen enthält, um eine Graph-Anwendung lokal mithilfe der VS Code-Erweiterung zu erstellen und auszuführen.

Öffnen des Beispielarbeitsbereichs in VS Code

Klonen Sie das Explore IoT Operations-Repository, wenn Sie es noch nicht getan haben.

Öffnen Sie den samples/wasm Ordner in Visual Studio Code, indem Sie im Menü Datei > Ordner öffnen auswählen und zum samples/wasm Ordner navigieren.

Die Operatoren erstellen

Drücken Sie, Ctrl+Shift+P um die Befehlspalette zu öffnen und nach Azure IoT-Vorgängen zu suchen: Erstellen Sie alle Datenflussoperatoren. Wählen Sie "Release" als Buildmodus aus.

Dieser Befehl erstellt alle Operatoren im Arbeitsbereich und erstellt .wasm Dateien im operators Ordner. Sie verwenden die .wasm Dateien, um die Graph-Anwendung lokal auszuführen.

Lokales Ausführen der Graph-Anwendung

Drücken Sie Ctrl+Shift+P , um die Befehlspalette zu öffnen und nach Azure IoT-Vorgängen zu suchen: Führen Sie Anwendungsdiagramm aus. Wählen Sie "Loslassen" als Ausführungsmodus aus. Mit diesem Befehl wird die Graph-Anwendung lokal mithilfe der lokalen Ausführungsumgebung mit der graph.dataflow.yaml Datei im Arbeitsbereich ausgeführt.

Es liest auch aus hostapp.env.list, um die Umgebungsvariable TK_CONFIGURATION_PARAMETERS für die Konfigurationsparameter des Data-Flows-Operators festzulegen.

Wenn Sie zur Eingabe von Daten aufgefordert werden, wählen Sie den data-and-images Ordner im Arbeitsbereich aus. Dieser Ordner enthält die Eingabedatendateien für die Graph-Anwendung einschließlich Temperatur- und Luftfeuchtigkeitsdaten und einige Bilder für das Momentaufnahmemodul.

Warten Sie, bis eine VS Code-Benachrichtigung angezeigt wird, dass die Protokolle bereit sind: Log files for the run can be found at ...\wasm\data-and-images\output\logs.

Die Ausgabe befindet sich im output Ordner unter dem data-and-images Ordner. Sie können den output Ordner im Arbeitsbereich öffnen, um die Ausgabedateien anzuzeigen. Die .txt Datei mit dem Datum und der Uhrzeit für den Dateinamen enthält die verarbeiteten Daten und sieht wie im folgenden Beispiel aus:

{"tst":"2025-09-19T04:19:13.530381+0000","topic":"sensors","qos":0,"retain":0,"payloadlen":312,"properties":{"payload-format-indicator":1,"message-expiry-interval":10,"correlation-data":"...","user-properties":{"__ts":"001758255553528:00000:...","__protVer":"1.0","__srcId":"mqtt-source"},"content-type":"application/json"},"payload":{"temperature":[{"count":2,"max":653.888888888889,"min":204.44444444444449,"average":429.16666666666669,"last":204.44444444444449,"unit":"C","overtemp":true}],"humidity":[{"count":3,"max":85,"min":45,"average":69.666666666666671,"last":79}],"object":[{"result":"notebook, notebook computer; sliding door"}]}}

Die Ausgabe zeigt, dass die Graph-Anwendung die Eingabedaten verarbeitet und die Ausgabe generiert hat. Die Ausgabe enthält Temperatur- und Luftfeuchtigkeitsdaten und die objekte, die in den Bildern erkannt wurden.

Erstellen eines neuen Diagramms mit benutzerdefinierten WASM-Modulen

In diesem Szenario wird gezeigt, wie Sie eine neue Graph-Anwendung mit benutzerdefinierten WASM-Modulen erstellen. Die Graph-Anwendung besteht aus zwei Operatoren: einem map Operator, der Temperaturwerte von Fahrenheit in Celsius umwandelt, und einem filter Operator, der Nachrichten mit Temperaturwerten über 500 °C herausfiltert.

Anstatt einen vorhandenen Beispielarbeitsbereich zu verwenden, erstellen Sie einen neuen Arbeitsbereich von Grund auf neu. Mit diesem Prozess erfahren Sie, wie Sie eine neue Graph-Anwendung erstellen und die Operatoren in Python und Rust programmieren.

Operator-Benennungsbeschränkung

Verwenden Sie derzeit keine Bindestriche (-) oder Unterstriche (_) in Operatornamen. Die VS Code-Erweiterung erzwingt diese Anforderung, aber wenn Sie Module manuell erstellen oder umbenennen, verursacht dies Probleme. Verwenden Sie einfache alphanumerische Namen für Module wie filter, , map, stateenrichoder schemafilter.

Erstellen eines neuen Diagrammanwendungsprojekts in Python

Drücken Sie, Ctrl+Shift+P um die Vs Code-Befehlspalette zu öffnen und nach Azure IoT-Vorgängen zu suchen: Erstellen einer neuen Datenflussanwendung:

  1. Wählen Sie für den Ordner einen Ordner aus, in dem Sie das Projekt erstellen möchten. Sie können einen neuen Ordner für dieses Projekt erstellen.
  2. Geben Sie my-graph als Namen ein.
  3. Wählen Sie Python als Sprache aus.
  4. Wählen Sie Map als Typ aus.
  5. Geben Sie map als Namen ein.

Sie verfügen jetzt über einen neuen VS Code-Arbeitsbereich mit der grundlegenden Projektstruktur und Startdateien. Die Startdateien enthalten die graph.dataflow.yaml Datei und den Quellcode der Kartenoperatorvorlage.

Von Bedeutung

Um ein Python-Modul in einer bereitgestellten Azure IoT Operations-Instanz zu verwenden, müssen Sie die Instanz bereitstellen, wobei das Brokerspeicherprofil auf "Mittel" oder " Hoch" festgelegt ist. Wenn Sie das Speicherprofil auf "Niedrig " oder " Tiny" festlegen, kann die Instanz das Python-Modul nicht abrufen.

Hinzufügen von Python-Code für das Kartenoperatormodul

Öffnen Sie die operators/map/map.py Datei, und ersetzen Sie den Inhalt durch den folgenden Code, um einen eingehenden Temperaturwert von Fahrenheit in Celsius zu konvertieren:

import json
from map_impl import exports
from map_impl import imports
from map_impl.imports import types

class Map(exports.Map):
    def init(self, configuration) -> bool:
        imports.logger.log(imports.logger.Level.INFO, "module4/map", "Init invoked")
        return True

    def process(self, message: types.DataModel) -> types.DataModel:
        # TODO: implement custom logic for map operator
        imports.logger.log(imports.logger.Level.INFO, "module4/map", "processing from python")

        # Ensure the input is of the expected type
        if not isinstance(message, types.DataModel_Message):
            raise ValueError("Unexpected input type: Expected DataModel_Message")

        # Extract and decode the payload
        payload_variant = message.value.payload
        if isinstance(payload_variant, types.BufferOrBytes_Buffer):
            # It's a Buffer handle - read from host
            imports.logger.log(imports.logger.Level.INFO, "module4/map", "Reading payload from Buffer")
            payload = payload_variant.value.read()
        elif isinstance(payload_variant, types.BufferOrBytes_Bytes):
            # It's already bytes
            imports.logger.log(imports.logger.Level.INFO, "module4/map", "Reading payload from Bytes")
            payload = payload_variant.value
        else:
            raise ValueError("Unexpected payload type")

        decoded = payload.decode("utf-8")

        # Parse the JSON data
        json_data = json.loads(decoded)

        # Check and update the temperature value
        if "temperature" in json_data and "value" in json_data["temperature"]:
            temp_f = json_data["temperature"]["value"]
            if isinstance(temp_f, int):
                # Convert Fahrenheit to Celsius
                temp_c = round((temp_f - 32) * 5.0 / 9.0)

                # Update the JSON data
                json_data["temperature"]["value"] = temp_c
                json_data["temperature"]["unit"] = "C"

                # Serialize the updated JSON back to bytes
                updated_payload = json.dumps(json_data).encode("utf-8")

                # Update the message payload
                message.value.payload = types.BufferOrBytes_Bytes(value=updated_payload)

        return message

Stellen Sie sicher, dass Docker ausgeführt wird. Drücken Sie dann Ctrl+Shift+P, um die Befehlspalette zu öffnen und nach Azure IoT-Operationen: Alle Datenflussoperatoren erstellen zu suchen. Erstellen Sie ein Releasemodul .

Der Buildvorgang platziert die map.wasm Datei für den map Operator im operators/map/bin/release Ordner.

Hinzufügen von Rostcode für das Filteroperatormodul

Erstellen Sie einen neuen Operator, indem Sie drücken Ctrl+Shift+P , um die Befehlspalette zu öffnen und nach Azure IoT-Vorgängen zu suchen: Datenflussoperator erstellen:

  1. Wählen Sie "Rost " als Sprache aus.
  2. Wählen Sie "Filter" als Operatortyp aus.
  3. Geben Sie filter als Namen ein.

Öffnen Sie die operators/filter/src/lib.rs Datei, und ersetzen Sie den Inhalt durch den folgenden Code, um Werte herauszufiltern, bei denen die Temperatur über 500 °C liegt:

mod filter_operator {
    use wasm_graph_sdk::macros::filter_operator;
    use serde_json::Value;

    fn filter_init(_configuration: ModuleConfiguration) -> bool {
        // Add code here to process the module init properties and module schemas from the configuration

        true
    }

    #[filter_operator(init = "filter_init")]
    fn filter(input: DataModel) -> Result<bool, Error> {

        // Extract payload from input to process
        let payload = match input {
            DataModel::Message(Message {
                payload: BufferOrBytes::Buffer(buffer),
                ..
            }) => buffer.read(),
            DataModel::Message(Message {
                payload: BufferOrBytes::Bytes(bytes),
                ..
            }) => bytes,
            _ => return Err(Error { message: "Unexpected input type".to_string() }),
        };

        // ... perform filtering logic here and return boolean
        if let Ok(payload_str) = std::str::from_utf8(&payload) {
            if let Ok(json) = serde_json::from_str::<Value>(payload_str) {
                if let Some(temp_c) = json["temperature"]["value"].as_i64() {
                    // Return true if temperature is above 500°C
                    return Ok(temp_c > 500);
                }
            }
        }

        Ok(false)
   }
}

Öffnen Sie die operators/filter/Cargo.toml Datei, und fügen Sie die folgenden Abhängigkeiten hinzu:

[dependencies]
# ...
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

Stellen Sie sicher, dass Docker ausgeführt wird. Drücken Sie dann Ctrl+Shift+P, um die Befehlspalette zu öffnen und nach Azure IoT-Operationen: Alle Datenflussoperatoren erstellen zu suchen. Erstellen Sie ein Releasemodul .

Der Buildvorgang platziert die filter.wasm Datei für den filter Operator im operators/filter/bin/release Ordner.

Lokales Ausführen der Graph-Anwendung mit Beispieldaten

Öffnen Sie die Datei graph.dataflow.yaml, und ersetzen Sie den Inhalt durch den folgenden Code:

metadata:
    $schema: "https://www.schemastore.org/aio-wasm-graph-config-1.0.0.json"
    name: "Temperature Monitoring"
    description: "A graph that converts temperature from Fahrenheit to Celsius, if temperature is above 500°C, then sends the processed data to the sink."
    version: "1.0.0"
    vendor: "Microsoft"
moduleRequirements:
    apiVersion: "1.1.0"
    runtimeVersion: "1.1.0"
operations:
  - operationType: source
    name: source
  - operationType: map
    name: map
    module: map
  - operationType: filter
    name: filter
    module: filter
  - operationType: sink
    name: sink
connections:
  - from:
      name: source
    to:
      name: map
  - from:
      name: map
    to:
      name: filter
  - from:
      name: filter
    to:
      name: sink

Kopieren Sie den Ordner data, der die Beispieldaten aus dem geklonten Beispieldaten-Repository explore-iot-operations\samples\wasm\data enthält, in den aktuellen Arbeitsbereich. Der data Ordner enthält drei JSON-Dateien mit Beispieleingabetemperaturdaten.

Drücken Sie, Ctrl+Shift+P um die Befehlspalette zu öffnen und nach Azure IoT-Vorgängen zu suchen: Anwendungsdiagramm ausführen:

  1. Wählen Sie die graph.dataflow.yaml Diagrammdatei aus.
  2. Wählen Sie "Loslassen" als Ausführungsmodus aus.
  3. Wählen Sie den Ordner aus, den data Sie in den Arbeitsbereich kopiert haben.

Der DevX-Container wird gestartet, um das Diagramm auszuführen. Das verarbeitete Ergebnis wird im data/output Ordner gespeichert.

Informationen zum Bereitstellen Ihrer benutzerdefinierten WASM-Module und -Diagramme in Ihrer Azure IoT Operations-Instanz finden Sie unter Bereitstellen von WASM-Modulen und Datenflussdiagrammen.

Unterstützung des Zustandsspeichers für WASM-Operatoren

In diesem Beispiel wird gezeigt, wie Sie den Zustandsspeicher mit WASM-Operatoren verwenden. Mit dem Statusspeicher können Operatoren Daten über die Nachrichtenverarbeitung hinweg beibehalten und abrufen und zustandsbehaftete Vorgänge in Ihren Datenflussdiagrammen ermöglichen.

Öffnen Sie den Beispielarbeitsbereich für den Zustandsspeicher

Klonen Sie das Explore IoT Operations-Repository, wenn Sie es noch nicht getan haben.

Öffnen Sie den samples/wasm/statestore-scenario Ordner in Visual Studio Code, indem Sie im Menü Datei > Ordner öffnen auswählen und zum samples/wasm/statestore-scenario Ordner navigieren. Dieser Ordner enthält die folgenden Ressourcen:

  • graph.dataflow.yaml – Die Konfiguration des Datenflussdiagramms mit einem statusspeicherfähigen Operator.
  • statestore.json – Zustandsspeicherkonfiguration mit Schlüssel-Wert-Paaren.
  • data/ - Beispieleingabedaten für Tests.
  • operators/ - Quellcode für die Operatoren otel-enrich und filter.

Konfigurieren des Statusspeichers

  1. Öffnen Sie die statestore.json Datei, um die konfiguration des aktuellen Zustandsspeichers anzuzeigen.

  2. Sie können die Werte von factoryId oder machineId zu Testzwecken ändern. Der Anreicherungsparameter verweist auf diese Schlüssel.

  3. Öffnen graph.dataflow.yaml Sie die Anreicherungskonfiguration, und überprüfen Sie sie. Die wesentlichen Abschnitte dieser Datei werden im folgenden Codeausschnitt angezeigt:

    moduleConfigurations:
  - name: module-otel-enrich/map
    parameters:
      enrichKeys:
        name: enrichKeys
        description: Comma separated list of DSS keys which will be fetched and added as attributes
        default: factoryId,machineId
operations:
  - operationType: "source"
    name: "source"
  - operationType: "map"
    name: "module-otel-enrich/map"
    module: "otel-enrich"
  - operationType: "sink"
    name: "sink"

    Der enrichKeys Standardwert (factoryId,machineId) des Parameters bestimmt, welche Schlüssel aus dem Statusspeicher abgerufen und als Attribute hinzugefügt werden.

  4. Stellen Sie sicher, dass jeder in enrichKeys aufgeführte Schlüssel in statestore.json vorhanden ist. Wenn Sie Schlüssel in statestore.json hinzufügen oder entfernen, aktualisieren Sie den default-Wert oder überschreiben ihn mit der TK_CONFIGURATION_PARAMETERS-Umgebungsvariablen.

Aktualisieren von Testdaten (optional)

Sie können die Testdaten im data/ Ordner ändern, um mit unterschiedlichen Eingabewerten zu experimentieren. Die Beispieldaten enthalten Temperaturwerte.

Erstellen und Ausführen des Zustandsspeicherszenarios

  1. Drücken Sie, Ctrl+Shift+P um die Befehlspalette zu öffnen und nach Azure IoT-Vorgängen zu suchen: Erstellen Sie alle Datenflussoperatoren.

  2. Wählen Sie "Release" als Buildmodus aus. Warten Sie, bis der Buildvorgang abgeschlossen ist.

  3. Drücken Sie Ctrl+Shift+P erneut und suchen Sie nach Azure IoT-Betrieb: Führen Sie Application Graph aus.

  4. Wählen Sie "Loslassen" als Ausführungsmodus aus.

  5. Wählen Sie den data Ordner im VS Code-Arbeitsbereich für Ihre Eingabedaten aus. Der DevX-Container wird gestartet, um das Diagramm mit der Beispieleingabe auszuführen.

Überprüfen der Statusspeicherfunktionalität

Nach Abschluss der Diagrammausführung:

  1. Zeigen Sie die Ergebnisse im data/output/ Ordner an.

  2. Öffnen Sie die generierte .txt Datei, um die verarbeiteten Daten anzuzeigen. Der user properties Abschnitt der Ausgabemeldungen enthält die Werte factoryId und machineId, die aus dem Statusspeicher abgerufen wurden.

  3. Überprüfen Sie die Protokolle data/output/logs/host-app.log , um zu überprüfen, ob der otel-enrich Operator Werte aus dem Statusspeicher abgerufen und als Benutzereigenschaften zu den Nachrichten hinzugefügt hat.

Schemaregistrierungsunterstützung für WASM-Module

In diesem Beispiel wird gezeigt, wie Sie die Schemaregistrierung mit WASM-Modulen verwenden. Mit der Schemaregistrierung können Sie Nachrichtenformate überprüfen und die Datenkonsistenz in der Datenflussverarbeitung sicherstellen.

Öffnen Sie den Beispielarbeitsbereich für die Schemaregistrierung.

Klonen Sie das Explore IoT Operations-Repository, wenn Sie es noch nicht getan haben.

Öffnen Sie den samples/wasm/schema-registry-scenario Ordner in Visual Studio Code, indem Sie im Menü Datei > Ordner öffnen auswählen und zum samples/wasm/schema-registry-scenario Ordner navigieren. Dieser Ordner enthält die folgenden Ressourcen:

  • graph.dataflow.yaml – Die Konfiguration des Datenflussdiagramms.
  • tk_schema_config.json – Das JSON-Schema, das von der Host-App lokal zum Überprüfen eingehender Nachrichtennutzlasten verwendet wird, bevor sie nachgelagerte Operatoren erreichen. Diese Datei wird mit jedem Schema synchronisiert, das Sie in Ihrer Microsoft Azure-Umgebung veröffentlichen.
  • data/ – Beispieleingabedaten mit unterschiedlichen Nachrichtenformaten zum Testen.
  • operators/filter/ - Quellcode für den Filteroperator.
  • (Optional) hostapp.env.list - Die VS Code-Erweiterung generiert automatisch einen zur Ausführungszeit, wenn Sie TK_SCHEMA_CONFIG_PATH=tk_schema_config.json hinzufügen. Wenn Sie eine eigene Schemadatei angeben, stellen Sie sicher, dass die Variable darauf verweist.

Grundlegendes zur Schemakonfiguration

Öffnen Sie die tk_schema_config.json Datei, um die Schemadefinition anzuzeigen:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "humidity": {
      "type": "integer"
    },
    "temperature": {
      "type": "number"
    }
  }
}

Dieses Schema definiert ein JSON-Objekt der obersten Ebene, das zwei numerische Eigenschaften enthalten kann: humidity (ganze Zahl) und temperature (Zahl). Fügen Sie ein "required": ["humidity", "temperature"]-Array hinzu, wenn Sie beide erforderlich machen wollen, oder erweitern Sie den properties-Abschnitt, wenn sich Ihr Payload-Format weiterentwickelt.

Die folgenden Einschränkungen gelten für die lokale Schemadatei (tk_schema_config.json). Die Schemadatei:

  • Verwendet die standardmäßige JSON Schema Entwurf-07-Syntax, denselben Entwurf, der von der Azure IoT Operations Schemaregistrierung unterstützt wird.
  • Ist funktional der gleiche Inhalt, den Sie in der Cloudschemaregistrierung registrieren. Sie können zwischen den beiden Anwendungen kopieren und einfügen, um konsistent zu bleiben.
  • Wird von der Host-App über die Umgebungsvariable TK_SCHEMA_CONFIG_PATHverwiesen.

Derzeit gelten die folgenden Einschränkungen in der lokalen Entwicklungslaufzeit:

  • Es wird nur eine Schemakonfigurationsdatei geladen. Es wird keine Mehrdatei-Einbindung oder Verzeichnisscan unterstützt.
  • $ref für externe Dateien oder URLs wird nicht lokal unterstützt. Halten Sie das Schema in sich geschlossen. Sie können interne JSON-Zeiger-Verweise wie {"$ref":"#/components/..."} verwenden.
  • Häufig verwendete draft-07-Schlüsselwörter wie type, properties, required, enum, minimum, maximum, allOf, anyOf, oneOf, not und items funktionieren alle. Der zugrunde liegende Validator ignoriert möglicherweise weniger häufige oder erweiterte Features wie contentEncoding und contentMediaType.
  • Halten Sie die Größe Ihrer Schemas auf unter ~1 MB, um schnelle Kaltstarts zu ermöglichen.
  • Versionsverwaltungs- und Schemaentwicklungsrichtlinien werden nicht lokal erzwungen. Sie sind dafür verantwortlich, mit der Cloudregistrierung in Einklang zu bleiben.

Wenn Sie auf erweiterte Konstrukte angewiesen sind, die die Überprüfung lokal fehlschlagen, überprüfen Sie dasselbe Schema nach der Veröffentlichung mit der Cloudregistrierung, um die Parität sicherzustellen.

Weitere Informationen finden Sie unter Azure IoT Operations-Schemaregistrierungskonzepte.

Überprüfen der Testdaten

Der data/ Ordner enthält drei Testdateien:

  • temperature_humidity_payload_1.json - Enthält sowohl Temperatur- als auch Luftfeuchtigkeitsdaten und besteht die Validierung. Der Luftfeuchtigkeitswert ist jedoch keine ganze Zahl, wie im Schema angegeben, sodass die Daten herausgefiltert werden.
  • temperature_humidity_payload_2.json - Enthält nur Luftfeuchtigkeitsdaten und wird herausgefiltert.
  • temperature_humidity_payload_3.json - Enthält sowohl Temperatur- als auch Luftfeuchtigkeitsdaten und besteht die Validierung.

Erstellen und Ausführen des Schemaregistrierungsszenarios

  1. Drücken Sie, Ctrl+Shift+P um die Befehlspalette zu öffnen und nach Azure IoT-Vorgängen zu suchen: Erstellen Sie alle Datenflussoperatoren.

  2. Wählen Sie "Release" als Buildmodus aus. Warten Sie, bis der Buildvorgang abgeschlossen ist.

  3. Drücken Sie Ctrl+Shift+P erneut und suchen Sie nach Azure IoT-Betrieb: Führen Sie Application Graph aus.

  4. Wählen Sie die graph.dataflow.yaml Diagrammdatei aus.

  5. Wählen Sie "Loslassen" als Ausführungsmodus aus.

  6. Wählen Sie den data Ordner im VS Code-Arbeitsbereich für Ihre Eingabedaten aus. Der DevX-Container wird gestartet, um das Diagramm mit der Beispieleingabe auszuführen.

Überprüfen der Schemaüberprüfung

Nach Abschluss der Verarbeitung:

  1. Überprüfen Sie den data/output/ Ordner auf die Ergebnisse.

  2. Die Ausgabe enthält nur die verarbeitete Version der temperature_humidity_payload_3.json Nachricht, da sie dem Schema entspricht.

  3. Die data/output/logs/host-app.log Datei enthält Protokolleinträge, die angeben, welche Nachrichten basierend auf der Schemaüberprüfung akzeptiert oder abgelehnt werden.

In diesem Beispiel wird gezeigt, wie die Schemaregistrierung eingehende Nachrichten überprüft und Nachrichten herausfiltert, die nicht dem definierten Schema entsprechen.

Debuggen von WASM-Modulen mithilfe der VS Code-Erweiterung

In diesem Beispiel wird gezeigt, wie Sie WASM-Module lokal mithilfe von Haltepunkten und dem integrierten Debugger in VS Code debuggen.

Voraussetzungen

Schließen Sie das Beispiel zur Schemaregistrierungsunterstützung für WASM-Module ab, um den Beispielarbeitsbereich zu erstellen.

Einrichten des Debuggings

  1. Öffnen Sie die Datei operators/filter/src/lib.rs im schema-registry-scenario Arbeitsbereich.

  2. Suchen Sie die filter-Funktion und legen Sie einen Haltepunkt fest, indem Sie auf den Rand neben der Zeilennummer klicken oder F9 drücken.

    fn filter(message: DataModel) -> Result<bool, Error> {
    let DataModel::Message(message) = input else {
        return Err(Error {message: "Unexpected input type.".to_string()});
    };
    // ... rest of function
}

Für das Debugging erstellen

  1. Drücken Sie, Ctrl+Shift+P um die Befehlspalette zu öffnen und nach Azure IoT-Vorgängen zu suchen: Erstellen Sie alle Datenflussoperatoren.

  2. Wählen Sie "Debuggen " als Buildmodus aus. Warten Sie, bis der Buildvorgang abgeschlossen ist.

Ausführen mit aktivierter Fehlersuche

  1. Drücken Sie Ctrl+Shift+P und suchen Sie nach Azure IoT-Vorgang: Anwendungsgrafik ausführen.

  2. Wählen Sie die lldb-debug.graph.dataflow.yaml Diagrammdatei aus.

  3. Wählen Sie "Debuggen " als Ausführungsmodus aus.

  4. Wählen Sie den data Ordner im VS Code-Arbeitsbereich für Ihre Eingabedaten aus. Der DevX-Container wird gestartet, um das Diagramm mit der Beispieleingabe auszuführen.

  5. Nachdem der DevX-Container gestartet wurde, sehen Sie, wie der Host-App-Container mit einem lldb-server zum Debuggen startet.

Sie verwenden eine spezielle Debugdiagrammdatei, da der aktuelle Debugger nur an einen benutzerdefinierten WASM-Operator in einer Debugsitzung angefügt werden kann. Mit dem dedizierten Debug-Diagramm können Sie Ihr normales graph.dataflow.yaml beibehalten und verhindern, dass der Debugger unvorhersehbar angehängt wird, wenn mehrere Module vorhanden sind.

So erstellen Sie eine eigene Debugdiagrammdatei:

  1. Kopieren Sie Ihre reguläre graph.dataflow.yaml Datei in eine neue Datei. Die Verwendung des lldb- Präfixes ist eine Konvention, aber der Name ist beliebig.
  2. Entfernen Sie alle anderen benutzerdefinierten WASM-Operatoren außer dem, den Sie debuggen möchten.
  3. Erstellen Sie den Zieloperator im Debugmodus neu, damit die Symbole verfügbar sind.
  4. Führen Sie das Debugdiagramm aus, wobei der Ausführungsmodus zum Debuggen festgelegt ist. Die Erweiterung startet ein lldb-server und ordnet VS Code automatisch zu.

Debuggen des WASM-Moduls

  1. Die Ausführung stoppt automatisch am Haltepunkt, den Sie in der filter Funktion festgelegt haben.

  2. Verwenden Sie die VS Code-Debugschnittstelle, um:

    • Überprüfen Sie Variablenwerte im Bereich "Variablen ".
    • Schrittweises Durchlaufen von Code mithilfe F10 oder F11.
    • Zeigen Sie den Aufrufstapel im Aufrufstapel-Panel an.
    • Fügen Sie Überwachungen für bestimmte Variablen oder Ausdrücke hinzu.

  3. Fahren Sie mit der Ausführung fort, indem Sie F5 drücken oder die Schaltfläche Weiter auswählen.

  4. Der Debugger hält am Haltepunkt für jede verarbeitete Nachricht an, sodass Sie den Datenfluss überprüfen können.

Tipps zum Debuggen

  • Verwenden Sie die Debugkonsole , um Ausdrücke auszuwerten und den Laufzeitstatus zu prüfen.
  • Legen Sie bedingte Haltepunkte fest, indem Sie mit der rechten Maustaste auf einen Haltepunkt klicken und Bedingungen hinzufügen.
  • Verwenden Sie F9, um Haltepunkte ein- und auszuschalten, ohne sie zu entfernen.
  • Im Bereich "Variablen " wird der aktuelle Status der lokalen Variablen und Funktionsparameter angezeigt.

Mit dieser Debugfunktion können Sie Probleme beheben, den Datenfluss verstehen und Ihre WASM-Modullogik überprüfen, bevor Sie sie in der Produktion bereitstellen.

Bekannte Probleme

Datenflusskonfiguration

  • Boolesche Werte in YAML: Boolesche Werte müssen als Zeichenfolgen zitiert werden, um Überprüfungsfehler zu vermeiden. Verwenden Sie z. B. "True" und "False" anstelle von true und false.

    Beispielfehler bei der Verwendung von nicht in Anführungszeichen gesetzten booleschen Ausdrücken:

    * spec.connections[2].from.arm: Invalid value: "boolean": spec.connections[2].from.arm in body must be of type string: "boolean"
* spec.connections[2].from.arm: Unsupported value: false: supported values: "False", "True"

  • Python-Modulanforderungen: Um Python-Module zu verwenden, muss Azure IoT Operations mit dem MQTT-Broker bereitgestellt werden, der für die Verwendung des Medium- oder High-Memory-Profils konfiguriert ist. Python-Module können nicht abgerufen werden, wenn das Speicherprofil auf "Niedrig" oder "Tiny" festgelegt ist.

  • Bereitstellungszeit von Modulen: Das Herunterladen und Anwenden von WASM-Modulen kann je nach Netzwerkbedingungen und Modulgröße einige Zeit dauern, typischerweise etwa eine Minute.

VS Code-Erweiterung

  • Build-Fehlerdetails: Wenn ein Build fehlschlägt, enthält die Fehlermeldung in der Popup-Benachrichtigung möglicherweise nicht genügend Details. Überprüfen Sie die Terminalausgabe auf spezifischere Fehlerinformationen.

  • Windows-Kompatibilität: Bei der ersten Ausführung einer Grafik-Anwendung auf Windows kann der Fehler "Befehl fehlgeschlagen mit Exit-Code 1" auftreten. Sollte dieser Fehler auftreten, wiederholen Sie den Vorgang, und es sollte ordnungsgemäß funktionieren.

  • Host-App-Stabilität: Die lokale Ausführungsumgebung funktioniert möglicherweise gelegentlich nicht mehr und erfordert einen Neustart zum Wiederherstellen.

Problembehandlung

Anzeigen von Protokollen

Führen Sie den folgenden Befehl aus, um Datenflussdienstprotokolle anzuzeigen:

kubectl logs -n azure-iot-operations -l app.kubernetes.io/name=microsoft-iotoperations-dataflows

Führen Sie zum Anzeigen von Datenverarbeitungsdienstprotokollen den folgenden Befehl aus:

kubectl logs -n azure-iot-operations -l app.kubernetes.io/instance=aio-dataflow-default

Führen Sie zum Anzeigen von Modulverwaltungsprotokollen den folgenden Befehl aus:

kubectl logs -n azure-iot-operations -l app.kubernetes.io/instance=aio-dataflow-graph-controller

Wiederherstellungsverfahren

Zurücksetzen der VS-Codeerweiterung: Wenn sich die VS Code-Erweiterung unerwartet verhält, versuchen Sie, sie zu deinstallieren und erneut zu installieren, und starten Sie VS Code neu.

  • Last updated on