Tworzenie modułów WASM dla przepływów danych w programie VS Code

Niestandardowa funkcja przetwarzania danych WebAssembly (WASM) w ramach Azure IoT Operations umożliwia przetwarzanie danych telemetrycznych w czasie rzeczywistym w klastrze Azure IoT Operations. Wdrażając niestandardowe moduły WASM, można definiować i wykonywać przekształcenia danych w ramach grafu przepływu danych lub łącznika HTTP/REST.

W tym artykule opisano sposób użycia rozszerzenia Azure IoT Operations Data Flow dla VS Code do tworzenia, testowania i debugowania modułów WASM lokalnie przed wdrożeniem ich w klastrze Azure IoT Operations. Dowiesz się, jak:

Uruchom aplikację grafową lokalnie, wykonując wstępnie przygotowany graf z przykładowymi danymi, aby zrozumieć podstawowy przepływ pracy.
Tworzenie niestandardowych modułów WASM przez utworzenie nowych operatorów w języku Python i Rust przy użyciu funkcji mapowania i filtrowania.
Użyj magazynu stanów, aby zachować stan podczas przetwarzania komunikatów.
Użyj weryfikacji rejestru schematów, aby zweryfikować formaty komunikatów przy użyciu schematów JSON przed przetworzeniem.
Debugowanie modułów WASM przy użyciu punktów przerwania i debugowania krokowego na potrzeby programowania lokalnego.

Rozszerzenie jest obsługiwane na następujących platformach:

Linux
Podsystem Windows dla systemu Linux (WSL)
Windows

Aby dowiedzieć się więcej na temat grafów i funkcji WASM w operacjach usługi Azure IoT, zobacz:

Wymagania wstępne

Środowisko programistyczne:

Visual Studio Code
(Opcjonalnie) Rozszerzenie REDHat YAML dla programu VS Code
Rozszerzenie przepływu danych operacji usługi Azure IoT dla programu VS Code.
Rozszerzenie CodeLLDB dla programu VS Code umożliwiające debugowanie modułów WASM
"Azure CLI"
ORAS CLI
Docker

Obrazy Docker

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

Używanie rozszerzenia programu VS Code do lokalnego uruchamiania aplikacji grafu

W tym przykładzie użyto przykładowego obszaru roboczego zawierającego wszystkie zasoby niezbędne do utworzenia i uruchomienia aplikacji grafu lokalnie przy użyciu rozszerzenia programu VS Code.

Otwieranie przykładowego obszaru roboczego w programie VS Code

Sklonuj repozytorium Explore IoT Operations, jeśli jeszcze tego nie zrobiłeś.

Otwórz folder samples/wasm w programie Visual Studio Code, wybierając pozycję Plik > Otwórz folder i przechodząc do folderu samples/wasm.

Budowanie operatorów

Naciśnij Ctrl+Shift+P , aby otworzyć paletę poleceń i wyszukać operacje usługi Azure IoT: skompiluj wszystkie operatory przepływu danych. Wybierz Release jako tryb kompilacji.

To polecenie buduje wszystkich operatorów w obszarze roboczym i tworzy pliki .wasm w folderze operators. Używasz plików .wasm do lokalnego uruchamiania aplikacji grafu.

Uruchamianie aplikacji grafu lokalnie

Naciśnij Ctrl+Shift+P , aby otworzyć paletę poleceń i wyszukać operacje usługi Azure IoT: Uruchom program Application Graph. Wybierz tryb Release jako tryb uruchamiania. To polecenie uruchamia aplikację graficzną lokalnie przy użyciu lokalnego środowiska wykonawczego z plikiem graph.dataflow.yaml w obszarze roboczym.

Odczytuje on również z hostapp.env.list , aby ustawić zmienną środowiskową TK_CONFIGURATION_PARAMETERS dla parametrów konfiguracji operatora przepływu danych.

Po wyświetleniu monitu o dane wejściowe wybierz data-and-images folder w obszarze roboczym. Ten folder zawiera pliki danych wejściowych dla aplikacji grafu, w tym dane dotyczące temperatury i wilgotności oraz niektóre obrazy modułu migawki.

Zaczekaj na powiadomienie programu VS Code, że dzienniki są gotowe: Log files for the run can be found at ...\wasm\data-and-images\output\logs.

Dane wyjściowe znajdują się w output folderze w folderze data-and-images . Możesz otworzyć output folder w obszarze roboczym, aby wyświetlić pliki wyjściowe. Plik .txt z datą i godziną nazwy pliku zawiera przetworzone dane i wygląda jak w poniższym przykładzie:

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

Dane wyjściowe pokazują, że aplikacja grafu przetworzyła dane wejściowe i wygenerowała dane wyjściowe. Dane wyjściowe obejmują dane dotyczące temperatury i wilgotności oraz obiekty wykryte na obrazach.

Tworzenie nowego grafu z niestandardowymi modułami WASM

W tym scenariuszu pokaże, jak utworzyć nową grafową aplikację z niestandardowymi modułami WASM. Aplikacja grafu składa się z dwóch operatorów: map operatora, który konwertuje wartości temperatury z Fahrenheita na Stopnie Celsjusza, oraz filter operator, który filtruje komunikaty z wartościami temperatury powyżej 500°C.

Zamiast używać istniejącego przykładowego obszaru roboczego, należy utworzyć nowy obszar roboczy od podstaw. Ten proces pozwala dowiedzieć się, jak utworzyć nową aplikację grafu i programować operatory w językach Python i Rust.

Ograniczenie nazewnictwa operatorów

Obecnie nie używaj łączników (-) ani podkreśleń (_) w nazwach operatorów. Rozszerzenie programu VS Code wymusza to wymaganie, ale jeśli tworzysz lub zmieniasz nazwy modułów ręcznie, powoduje to problemy. Użyj prostych nazw alfanumerycznych dla modułów, takich jak filter, map, stateenrichlub schemafilter.

Tworzenie nowego projektu aplikacji grafu w języku Python

Naciśnij Ctrl+Shift+P , aby otworzyć paletę poleceń programu VS Code i wyszukać operacje usługi Azure IoT: Utwórz nową aplikację przepływu danych:

W folderze wybierz folder, w którym chcesz utworzyć projekt. Możesz utworzyć nowy folder dla tego projektu.
Wprowadź my-graph jako nazwę.
Wybierz język Python jako język.
Wybierz pozycję Mapa jako typ.
Wprowadź map jako nazwę.

Masz teraz nowy obszar roboczy programu VS Code z podstawową strukturą projektu i plikami startowymi. Pliki początkowe obejmują graph.dataflow.yaml plik i kod źródłowy szablonu operatora mapy.

Ważne

Aby użyć modułu języka Python w wdrożonym wystąpieniu operacji usługi Azure IoT, należy wdrożyć wystąpienie z profilem pamięci brokera ustawionym na średni lub wysoki. Jeśli dla profilu pamięci ustawiono wartość Niska lub Mała, wystąpienie nie może ściągnąć modułu języka Python.

Dodawanie kodu języka Python dla modułu operatora mapy

operators/map/map.py Otwórz plik i zastąp zawartość następującym kodem, aby przekonwertować przychodzącą wartość temperatury z Fahrenheita na stopnie Celsjusza:

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

Upewnij się, że platforma Docker jest uruchomiona. Następnie naciśnij Ctrl+Shift+P , aby otworzyć paletę poleceń i wyszukać operacje usługi Azure IoT: Kompilowanie wszystkich operatorów przepływu danych. Utwórz moduł wydania .

Podczas procesu budowania plik map.wasm dla operatora map jest umieszczany w folderze operators/map/bin/release.

Dodawanie kodu Rust dla modułu operatora filtru

Utwórz nowy operator, naciskając Ctrl+Shift+P , aby otworzyć paletę poleceń i wyszukać operacje usługi Azure IoT: Tworzenie operatora przepływu danych:

Wybierz język Rust.
Wybierz pozycję Filtruj jako typ operatora.
Wprowadź filter jako nazwę.

operators/filter/src/lib.rs Otwórz plik i zastąp zawartość następującym kodem, aby odfiltrować wartości, w których temperatura przekracza 500°C:

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

operators/filter/Cargo.toml Otwórz plik i dodaj następujące zależności:

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

Podczas procesu budowania plik filter.wasm dla operatora filter jest umieszczany w folderze operators/filter/bin/release.

Uruchom aplikację grafu lokalnie z przykładowymi danymi

graph.dataflow.yaml Otwórz plik i zastąp zawartość następującym kodem:

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

data Skopiuj folder zawierający przykładowe dane ze sklonowanego repozytorium explore-iot-operations\samples\wasm\data próbek do bieżącego obszaru roboczego. Folder data zawiera trzy pliki JSON z przykładowymi danymi wejściowymi temperatury.

Naciśnij Ctrl+Shift+P , aby otworzyć paletę poleceń i wyszukać operacje usługi Azure IoT: Uruchom program Application Graph:

graph.dataflow.yaml Wybierz plik grafu.
Wybierz tryb Release jako tryb uruchamiania.
data Wybierz folder skopiowany do obszaru roboczego.

Kontener DevX uruchamia się w celu wykonania grafu. Przetworzony wynik jest zapisywany w folderze data/output .

Aby dowiedzieć się, jak wdrożyć niestandardowe moduły WASM i wykres przepływu danych w ramach instancji operacyjnej Azure IoT, zobacz Wdrażanie modułów WASM i wykresów przepływu danych.

Obsługa przechowywania stanów dla operatorów WASM

W tym przykładzie pokazano, jak używać przechowywania stanu z operatorami WASM. Magazyn stanów umożliwia operatorom utrwalanie i pobieranie danych w przetwarzaniu komunikatów oraz umożliwia wykonywanie operacji stanowych na wykresach przepływu danych.

Otwórz przykładowy obszar roboczy magazynu stanowego

Sklonuj repozytorium Explore IoT Operations, jeśli jeszcze tego nie zrobiłeś.

Otwórz folder samples/wasm/statestore-scenario w programie Visual Studio Code, wybierając pozycję Plik > Otwórz folder i przechodząc do folderu samples/wasm/statestore-scenario. Ten folder zawiera następujące zasoby:

graph.dataflow.yaml — Konfiguracja grafu przepływu danych z włączonym operatorem magazynu stanów.
statestore.json — Konfiguracja magazynu stanów z parami klucz-wartość.
data/ — Przykładowe dane wejściowe do testowania.
operators/ - Kod źródłowy dla operatorów wzbogacania i filtrowania otel.

Konfigurowanie magazynu stanów

Otwórz plik statestore.json, aby wyświetlić aktualną konfigurację magazynu stanów.
Możesz zmodyfikować wartości factoryId lub machineId do testowania. Parametr wzbogacania odwołuje się do tych kluczy.

Otwórz graph.dataflow.yaml i przejrzyj konfigurację wzbogacania. Istotne sekcje tego pliku są wyświetlane w następującym fragmencie kodu:

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"

enrichKeys Wartość domyślna parametru (factoryId,machineId) określa, które klucze są pobierane z magazynu stanów i dodawane jako atrybuty.

Upewnij się, że każdy klucz wymieniony w pliku enrichKeys istnieje w pliku statestore.json. Jeśli dodasz lub usuniesz klucze w statestore.json, zaktualizuj wartość default lub nadpisz ją, używając zmiennej środowiskowej TK_CONFIGURATION_PARAMETERS.

Aktualizowanie danych testowych (opcjonalnie)

Możesz zmodyfikować dane testowe w folderze data/ , aby eksperymentować z różnymi wartościami wejściowymi. Przykładowe dane obejmują odczyty temperatury.

Kompilowanie i uruchamianie scenariusza magazynu stanów

Naciśnij Ctrl+Shift+P , aby otworzyć paletę poleceń i wyszukać operacje usługi Azure IoT: skompiluj wszystkie operatory przepływu danych.
Wybierz Release jako tryb kompilacji. Poczekaj na zakończenie kompilacji.
Naciśnij Ctrl+Shift+P ponownie i wyszukaj pozycję Operacje usługi Azure IoT: Uruchom program Application Graph.
Wybierz tryb Release jako tryb uruchamiania.
data Wybierz folder w obszarze roboczym programu VS Code dla danych wejściowych. Kontener DevX zostanie uruchomiony, aby uruchomić graf z przykładowymi danymi wejściowymi.

Weryfikowanie funkcji magazynu stanów

Po zakończeniu wykonywania grafu:

Wyświetl wyniki w folderze data/output/ .
Otwórz wygenerowany .txt plik, aby wyświetlić przetworzone dane. Sekcja komunikatów wyjściowych user properties zawiera wartości factoryId i machineId, które są pobrane z magazynu stanów.
Sprawdź dzienniki w data/output/logs/host-app.log, aby zweryfikować, że operator otel-enrich pobrał wartości ze sklepu stanu i dodał je jako właściwości użytkownika do wiadomości.

Obsługa rejestru schematów dla modułów WASM

W tym przykładzie pokazano, jak używać rejestru schematów z modułami WASM. Rejestr schematów umożliwia weryfikowanie formatów komunikatów i zapewnienie spójności danych w przetwarzaniu przepływu danych.

Otwórz przykładowy obszar roboczy rejestru schematów

Sklonuj repozytorium Explore IoT Operations, jeśli jeszcze tego nie zrobiłeś.

Otwórz folder samples/wasm/schema-registry-scenario w programie Visual Studio Code, wybierając pozycję Plik > Otwórz folder i przechodząc do folderu samples/wasm/schema-registry-scenario. Ten folder zawiera następujące zasoby:

graph.dataflow.yaml — Konfiguracja grafu przepływu danych.
tk_schema_config.json — Schemat JSON, którego aplikacja hosta używa lokalnie do sprawdzania poprawności przychodzących ładunków wiadomości, zanim dotrą one do operatorów dalszego przetwarzania. Zachowaj synchronizację tego pliku z dowolnym schematem publikowanym w środowisku platformy Microsoft Azure.
data/ — Przykładowe dane wejściowe z różnymi formatami komunikatów na potrzeby testowania.
operators/filter/ - Kod źródłowy operatora filtru.
(Opcjonalnie) hostapp.env.list — Rozszerzenie programu VS Code automatycznie generuje jeden podczas działania, dodając element TK_SCHEMA_CONFIG_PATH=tk_schema_config.json. Jeśli podasz własny plik schematu, upewnij się, że zmienna wskazuje go.

Omówienie konfiguracji schematu

Otwórz plik, tk_schema_config.json aby wyświetlić definicję schematu:

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

Ten schemat definiuje obiekt JSON najwyższego poziomu, który może zawierać dwie właściwości liczbowe: humidity (liczba całkowita) i temperature (liczba). Dodaj tablicę "required": ["humidity", "temperature"], jeśli musisz uczynić je wymaganymi, lub rozszerz sekcję properties w miarę rozwoju formatu ładunku.

Następujące ograniczenia dotyczą lokalnego pliku schematu (tk_schema_config.json). Plik schematu:

Używa standardowej składni schematu JSON draft-07, tej samej wersji roboczej obsługiwanej przez rejestr schematów operacji usługi Azure IoT.
Jest funkcjonalnie taką samą zawartością, którą rejestrujesz w rejestrze schematów chmury. Możesz skopiować i wkleić między nimi, aby zachować spójność.
Jest przywołyny przez aplikację hosta za pomocą zmiennej środowiskowej TK_SCHEMA_CONFIG_PATH.

Obecnie w lokalnym środowisku uruchomieniowym programowania obowiązują następujące ograniczenia:

Załadowano tylko jeden plik konfiguracji schematu. Nie jest obsługiwane żadne skanowanie obejmujące wiele plików ani katalogów.
$ref zewnętrzne pliki lub adresy URL nie są obsługiwane lokalnie. Zachowaj samodzielny schemat. Możesz użyć wewnętrznych odwołań wskaźnika JSON, takich jak {"$ref":"#/components/..."}.
Wszystkie powszechnie używane słowa kluczowe draft-07, takie jak type, properties, required, enum, minimum, maximum, allOf, anyOf, oneOf, not i items, działają. Podstawowy moduł sprawdzania poprawności może ignorować mniej typowe lub zaawansowane funkcje, takie jak contentEncoding i contentMediaType.
Zachowaj rozmiar schematów na mniej niż ok. 1 MB dla szybkich zimnych startów.
Zasady ewolucji wersji i schematu nie są wymuszane lokalnie. Jesteś odpowiedzialny za utrzymanie zgodności z rejestrem w chmurze.

Jeśli korzystasz z zaawansowanych konstrukcji, które kończą się niepowodzeniem lokalnie, zweryfikuj ten sam schemat względem rejestru w chmurze po opublikowaniu, aby zapewnić parzystość.

Aby dowiedzieć się więcej, zobacz Pojęcia dotyczące rejestru schematów operacji usługi Azure IoT.

Przeglądanie danych testowych

Folder data/ zawiera trzy pliki testowe:

temperature_humidity_payload_1.json — Zawiera zarówno dane dotyczące temperatury, jak i wilgotności oraz przechodzi walidację. Jednak wartość wilgotności nie jest liczbą całkowitą określoną w schemacie, więc dane są odfiltrowane.
temperature_humidity_payload_2.json — Zawiera tylko dane wilgotności i jest odfiltrowany.
temperature_humidity_payload_3.json — Zawiera zarówno dane dotyczące temperatury, jak i wilgotności oraz przechodzi walidację.

Kompilowanie i uruchamianie scenariusza rejestru schematów

Naciśnij Ctrl+Shift+P , aby otworzyć paletę poleceń i wyszukać operacje usługi Azure IoT: skompiluj wszystkie operatory przepływu danych.
Wybierz Release jako tryb kompilacji. Poczekaj na zakończenie kompilacji.
Naciśnij Ctrl+Shift+P ponownie i wyszukaj pozycję Operacje usługi Azure IoT: Uruchom program Application Graph.
graph.dataflow.yaml Wybierz plik grafu.
Wybierz tryb Release jako tryb uruchamiania.
data Wybierz folder w obszarze roboczym programu VS Code dla danych wejściowych. Kontener DevX zostanie uruchomiony, aby uruchomić graf z przykładowymi danymi wejściowymi.

Zweryfikuj walidację schematu

Po zakończeniu przetwarzania:

Sprawdź data/output/ folder, aby znaleźć wyniki.
Dane wyjściowe zawierają tylko przetworzoną wersję komunikatu temperature_humidity_payload_3.json , ponieważ jest ona zgodna ze schematem.
Plik data/output/logs/host-app.log zawiera wpisy dziennika wskazujące, które komunikaty są akceptowane lub odrzucane na podstawie weryfikacji schematu.

W tym przykładzie pokazano, jak rejestr schematów weryfikuje komunikaty przychodzące i filtruje komunikaty, które nie są zgodne ze zdefiniowanym schematem.

Debugowanie modułów WASM przy użyciu rozszerzenia programu VS Code

W tym przykładzie pokazano, jak debugować moduły WASM lokalnie przy użyciu punktów przerwania i zintegrowanego debugera w programie VS Code.

Wymagania wstępne

Ukończ przykład obsługi rejestru schematów dla modułów WASM , aby skonfigurować przykładowy obszar roboczy.

Konfigurowanie debugowania

Otwórz plik operators/filter/src/lib.rs w obszarze roboczym schema-registry-scenario .

filter Znajdź funkcję i ustaw punkt przerwania, klikając na marginesie obok numeru wiersza lub naciskając F9.

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
}

Kompilowanie na potrzeby debugowania

Naciśnij Ctrl+Shift+P , aby otworzyć paletę poleceń i wyszukać operacje usługi Azure IoT: skompiluj wszystkie operatory przepływu danych.
Wybierz pozycję Debuguj jako tryb kompilacji. Poczekaj na zakończenie kompilacji.

Uruchamianie z włączonym debugowaniem

Naciśnij Ctrl+Shift+P i wyszukaj pozycję Operacje usługi Azure IoT: Uruchom program Application Graph.
lldb-debug.graph.dataflow.yaml Wybierz plik grafu.
Wybierz pozycję Debuguj jako tryb uruchamiania.
data Wybierz folder w obszarze roboczym programu VS Code dla danych wejściowych. Kontener DevX zostanie uruchomiony, aby uruchomić graf z przykładowymi danymi wejściowymi.
Po uruchomieniu kontenera DevX zobaczysz, jak kontener host-app uruchamia się z elementem lldb-server do celów debugowania.

Używasz specjalnego pliku grafu debugowania, ponieważ bieżący debuger może podłączyć się tylko do niestandardowego operatora WASM w sesji debugowania. Specjalny wykres debugowania pozwala zachować normalne działanie graph.dataflow.yaml i zapobiega nieprzewidywalnemu dołączaniu debugera, gdy istnieje wiele modułów.

Aby utworzyć własny plik grafu debugowania:

Skopiuj zwykły graph.dataflow.yaml plik do nowego pliku. Używanie prefiksu lldb- jest konwencją, ale nazwa jest dowolna.
Usuń wszystkie inne niestandardowe operatory WASM z wyjątkiem tego, który chcesz debugować.
Ponownie skompiluj operator docelowy w trybie debugowania, aby symbole były dostępne.
Uruchom wykres debugowania z trybem uruchamiania ustawionym na debug. Rozszerzenie uruchamia lldb-server i automatycznie łączy z programem VS Code.

Debugowanie modułu WASM

Wykonanie automatycznie zatrzymuje się w punkcie przerwania filter, który ustawiłeś w funkcji.
Użyj interfejsu debugowania programu VS Code, aby:
- Sprawdź wartości zmiennych w panelu Zmienne .
- Przechodź przez kod używając F10 lub F11.
- Wyświetl stos wywołań w panelu Stos wywołań.
- Dodaj zegarki dla określonych zmiennych lub wyrażeń.
Kontynuuj wykonywanie, naciskając F5 lub wybierając przycisk Kontynuuj .
Debuger zatrzymuje się w punkcie przerwania dla każdego przetwarzanego komunikatu, umożliwiając inspekcję przepływu danych.

Porady dotyczące debugowania

Użyj konsoli debugowania , aby ocenić wyrażenia i sprawdzić stan środowiska uruchomieniowego.
Ustaw warunkowe punkty przerwania, klikając prawym przyciskiem myszy punkt przerwania i dodając warunki.
Użyj F9 do włączania i wyłączania punktów przerwania bez ich usuwania.
Panel Zmienne pokazuje bieżący stan zmiennych lokalnych i parametrów funkcji.

Ta funkcja debugowania umożliwia rozwiązywanie problemów, zrozumienie przepływu danych i zweryfikowanie logiki modułu WASM przed wdrożeniem w środowisku produkcyjnym.

Znane problemy

Konfiguracja przepływu danych

Wartości logiczne w języku YAML: wartości logiczne muszą być cytowane jako ciągi, aby uniknąć błędów walidacji. Na przykład użyj poleceń "True" i "False" zamiast true i false.

Przykładowy błąd podczas używania niekwotowanych wartości logicznych:
```
* 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"
```
Wymagania dotyczące modułu języka Python: Aby korzystać z modułów języka Python, należy wdrożyć operacje usługi Azure IoT za pomocą brokera MQTT skonfigurowanego do korzystania z profilu pamięci średniej lub wysokiej . Nie można ściągnąć modułów języka Python, gdy profil pamięci jest ustawiony na wartość Niska lub Mała.
Czas wdrażania modułu: ściąganie i stosowanie modułów WASM może zająć trochę czasu, zazwyczaj około minuty, w zależności od warunków sieciowych i rozmiaru modułu.

Rozszerzenie programu VS Code

Szczegóły błędu kompilacji: jeśli kompilacja zakończy się niepowodzeniem, komunikat o błędzie w wyskakującym powiadomieniu może nie dostarczyć wystarczających szczegółów. Sprawdź dane wyjściowe terminalu, aby uzyskać bardziej szczegółowe informacje o błędzie.
Zgodność systemu Windows: W systemie Windows przy pierwszym uruchomieniu aplikacji grafowej może wystąpić błąd "polecenie nie powiodło się z kodem zakończenia 1". Jeśli wystąpi ten błąd, spróbuj ponownie wykonać operację, a powinna działać poprawnie.
Stabilność aplikacji hosta: lokalne środowisko wykonawcze może czasami przestać działać i wymagać ponownego uruchomienia w celu odzyskania.

Rozwiązywanie problemów

Wyświetlanie dzienników

Aby wyświetlić dzienniki usługi przepływu danych, uruchom następujące polecenie:

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

Aby wyświetlić dzienniki usługi przetwarzania danych, uruchom następujące polecenie:

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

Aby wyświetlić dzienniki zarządzania modułami, uruchom następujące polecenie:

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

Procedury odzyskiwania

Resetowanie rozszerzenia programu VS Code: jeśli rozszerzenie programu VS Code zachowuje się nieoczekiwanie, spróbuj odinstalować je i ponownie zainstalować, a następnie ponownie uruchomić program VS Code.

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-12-10

Udostępnij przez

Tworzenie modułów WASM dla przepływów danych w programie VS Code

Wymagania wstępne

Używanie rozszerzenia programu VS Code do lokalnego uruchamiania aplikacji grafu

Otwieranie przykładowego obszaru roboczego w programie VS Code

Budowanie operatorów

Uruchamianie aplikacji grafu lokalnie

Tworzenie nowego grafu z niestandardowymi modułami WASM

Ograniczenie nazewnictwa operatorów

Tworzenie nowego projektu aplikacji grafu w języku Python

Dodawanie kodu języka Python dla modułu operatora mapy

Dodawanie kodu Rust dla modułu operatora filtru

Uruchom aplikację grafu lokalnie z przykładowymi danymi

Obsługa przechowywania stanów dla operatorów WASM

Otwórz przykładowy obszar roboczy magazynu stanowego

Konfigurowanie magazynu stanów

Aktualizowanie danych testowych (opcjonalnie)

Kompilowanie i uruchamianie scenariusza magazynu stanów

Weryfikowanie funkcji magazynu stanów

Obsługa rejestru schematów dla modułów WASM

Otwórz przykładowy obszar roboczy rejestru schematów

Omówienie konfiguracji schematu

Przeglądanie danych testowych

Kompilowanie i uruchamianie scenariusza rejestru schematów

Zweryfikuj walidację schematu

Debugowanie modułów WASM przy użyciu rozszerzenia programu VS Code

Wymagania wstępne

Konfigurowanie debugowania

Kompilowanie na potrzeby debugowania

Uruchamianie z włączonym debugowaniem

Debugowanie modułu WASM

Porady dotyczące debugowania

Znane problemy

Konfiguracja przepływu danych

Rozszerzenie programu VS Code

Rozwiązywanie problemów

Wyświetlanie dzienników

Procedury odzyskiwania

Sprzężenie zwrotne

Dodatkowe źródła