Compartir a través de

Compilación de módulos WASM para flujos de datos en VS Code

La característica de procesamiento de datos WebAssembly (WASM) personalizada en Azure IoT Operations permite el procesamiento de datos de telemetría en tiempo real dentro del clúster de operaciones de Azure IoT. Al implementar módulos WASM personalizados, puede definir y ejecutar transformaciones de datos como parte del grafo de flujo de datos o el conector HTTP/REST.

En este artículo se describe cómo usar la extensión vs Code de Azure IoT Operations Data Flow para desarrollar, probar y depurar los módulos WASM localmente antes de implementarlos en el clúster de operaciones de Azure IoT. Aprenderá a:

  • Ejecute una aplicación de grafos localmente mediante la ejecución de un grafo creado previamente con datos de ejemplo para comprender el flujo de trabajo básico.
  • Cree módulos WASM personalizados creando nuevos operadores en Python y Rust, con funcionalidades de map y filter.
  • Utiliza el almacén de estado para mantener el estado durante el procesamiento de mensajes.
  • Use la validación del registro de esquema para validar los formatos de mensaje mediante esquemas JSON antes de procesarlos.
  • Depuración de módulos WASM mediante puntos de interrupción y depuración paso a paso para el desarrollo local.

La extensión se admite en las siguientes plataformas:

  • Linux
  • Subsistema de Windows para Linux (WSL)
  • Windows

Para más información sobre los grafos y WASM en Azure IoT Operations, consulte:

Prerrequisitos

Entorno de desarrollo:

Imágenes de 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

Uso de la extensión de VS Code para ejecutar una aplicación de grafos localmente

En este ejemplo se usa un área de trabajo de ejemplo que contiene todos los recursos necesarios para compilar y ejecutar una aplicación de grafos localmente mediante la extensión de VS Code.

Apertura del área de trabajo de ejemplo en VS Code

Clona el repositorio Explore IoT Operations si aún no lo has hecho.

Abra la samples/wasm carpeta en Visual Studio Code; para ello, seleccione Abrir > carpeta y vaya a la samples/wasm carpeta.

Compilación de los operadores

Presione Ctrl+Shift+P para abrir la paleta de comandos y busque Operaciones de Azure IoT: Compilar todos los operadores de flujo de datos. Seleccione release (Versión ) como modo de compilación.

Este comando compila todos los operadores del área de trabajo y crea .wasm archivos en la operators carpeta . Los .wasm archivos se usan para ejecutar la aplicación de grafos localmente.

Ejecución local de la aplicación de grafos

Pulse Ctrl+Shift+P para abrir la paleta de comandos y busque Operaciones de IoT de Azure: ejecutar gráfico de aplicaciones. Seleccione release como modo de ejecución. Este comando ejecuta la aplicación de grafos localmente mediante el entorno de ejecución local con el graph.dataflow.yaml archivo en el área de trabajo.

También lee de hostapp.env.list para establecer la variable de entorno TK_CONFIGURATION_PARAMETERS para los parámetros de configuración del operador de flujo de datos.

Cuando se le pidan datos de entrada, seleccione la data-and-images carpeta en el área de trabajo. Esta carpeta contiene los archivos de datos de entrada para la aplicación de grafos, incluidos los datos de temperatura y humedad, y algunas imágenes para el módulo de instantáneas.

Espere hasta que vea una notificación de VS Code de que los registros están listos: Log files for the run can be found at ...\wasm\data-and-images\output\logs.

La salida se encuentra en la output carpeta debajo de la data-and-images carpeta . Puede abrir la output carpeta en el área de trabajo para ver los archivos de salida. El .txt archivo con la fecha y hora del nombre de archivo contiene los datos procesados y tiene un aspecto similar al ejemplo siguiente:

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

La salida muestra que la aplicación de grafo procesó los datos de entrada y generó la salida. La salida incluye datos de temperatura y humedad, y los objetos detectados en las imágenes.

Crear un grafo nuevo con módulos WASM personalizados

En este escenario se muestra cómo crear una nueva aplicación de grafos con módulos WASM personalizados. La aplicación de grafos consta de dos operadores: un map operador que convierte valores de temperatura de Fahrenheit a Celsius, y un filter operador que filtra los mensajes con valores de temperatura superiores a 500 °C.

En lugar de usar un área de trabajo de ejemplo existente, cree una nueva área de trabajo desde cero. Este proceso le permite aprender a crear una nueva aplicación de grafos y programar los operadores en Python y Rust.

Restricción de nomenclatura de operadores

Actualmente, no use guiones (-) ni caracteres de subrayado (_) en nombres de operador. La extensión de VS Code aplica este requisito, pero si crea o cambia el nombre de los módulos manualmente, provoca problemas. Use nombres alfanuméricos simples para módulos como filter, map, stateenricho schemafilter.

Creación de un nuevo proyecto de aplicación de grafos en Python

Presione Ctrl+Shift+P para abrir la paleta de comandos de VS Code y busque Operaciones de Azure IoT: Creación de una nueva aplicación de flujo de datos:

  1. Para la carpeta, seleccione una carpeta en la que quiera crear el proyecto. Puede crear una carpeta para este proyecto.
  2. Escriba my-graph como nombre.
  3. Seleccione Python como lenguaje.
  4. Seleccione Mapa como tipo.
  5. Escriba map como nombre.

Ahora tiene un nuevo área de trabajo de VS Code con la estructura básica del proyecto y los archivos de inicio. Los archivos de inicio incluyen el graph.dataflow.yaml archivo y el código fuente de la plantilla del operador de mapa.

Importante

Para usar un módulo de Python en una instancia de Azure IoT Operations implementada, debe implementar la instancia con el perfil de memoria del agente establecido en Medio o Alto. Si establece el perfil de memoria en Low o Tiny, la instancia no puede extraer el módulo de Python.

Adición de código de Python para el módulo del operador de mapa

Abra el archivo y reemplace el operators/map/map.py contenido por el código siguiente para convertir un valor de temperatura entrante de Fahrenheit a Celsius:

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

Asegúrese de que Docker se está ejecutando. A continuación, presione Ctrl+Shift+P para abrir la paleta de comandos y busque Operaciones de Azure IoT: Compilar todos los operadores de flujo de datos. Cree un módulo de lanzamiento.

El proceso de compilación coloca el archivo map.wasm para el operador map en la carpeta operators/map/bin/release.

Adición de código de Rust para el módulo de operador de filtro

Para crear un operador, presione Ctrl+Shift+P para abrir la paleta de comandos y busque Operaciones de Azure IoT: Creación del operador de flujo de datos:

  1. Seleccione Rust como idioma.
  2. Seleccione Filtrar como tipo de operador.
  3. Escriba filter como nombre.

Abra el archivo y reemplace el operators/filter/src/lib.rs contenido por el código siguiente para filtrar los valores en los que la temperatura está por encima de 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)
   }
}

Abra el operators/filter/Cargo.toml archivo y agregue las siguientes dependencias:

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

Asegúrese de que Docker se está ejecutando. A continuación, presione Ctrl+Shift+P para abrir la paleta de comandos y busque Operaciones de Azure IoT: Compilar todos los operadores de flujo de datos. Cree un módulo de lanzamiento.

El proceso de compilación coloca el archivo filter.wasm para el operador filter en la carpeta operators/filter/bin/release.

Ejecución local de la aplicación de grafos con datos de ejemplo

Abra el archivo graph.dataflow.yaml y reemplace el contenido por el código siguiente:

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

Copie la data carpeta que contiene los datos de ejemplo del repositorio explore-iot-operations\samples\wasm\data de ejemplos clonados en el área de trabajo actual. La data carpeta contiene tres archivos JSON con datos de temperatura de entrada de ejemplo.

Presione Ctrl+Shift+P para abrir la paleta de comandos y busque Operaciones de Azure IoT: Ejecutar gráfico de aplicaciones:

  1. Seleccione el archivo de gráfico graph.dataflow.yaml.
  2. Seleccione release como modo de ejecución.
  3. Seleccione la data carpeta que copió en el área de trabajo.

El contenedor DevX se inicia para ejecutar el grafo. El resultado procesado se guarda en la data/output carpeta .

Para obtener información sobre cómo implementar los módulos y grafos de WASM personalizados en la instancia de Azure IoT Operations, consulte Implementación de módulos WASM y gráficos de flujo de datos.

Compatibilidad con el almacén de estado para operadores WASM

En este ejemplo se muestra cómo usar el almacén de estado con operadores WASM. El almacén de estados permite a los operadores conservar y recuperar datos en el procesamiento de mensajes y permite operaciones con estado en los gráficos de flujo de datos.

Abra el área de trabajo de ejemplo del almacén de estado

Clona el repositorio Explore IoT Operations si aún no lo has hecho.

Abra la samples/wasm/statestore-scenario carpeta en Visual Studio Code; para ello, seleccione Abrir > carpeta y vaya a la samples/wasm/statestore-scenario carpeta. Esta carpeta contiene los siguientes recursos:

  • graph.dataflow.yaml: la configuración del grafo de flujo de datos con un operador habilitado para el almacén de estados.
  • statestore.json - Configuración del almacén de estado con pares clave-valor.
  • data/ - Datos de entrada de ejemplo para pruebas.
  • operators/ - Código fuente para los operadores otel-enrich y filter.

Configuración del almacén de estado

  1. Abra el archivo statestore.json para ver la configuración del almacén de estado actual.

  2. Puede modificar los valores de factoryId o machineId para las pruebas. El parámetro de enriquecimiento hace referencia a estas claves.

  3. Abra graph.dataflow.yaml y revise la configuración de enriquecimiento. Las secciones significativas de este archivo se muestran en el siguiente fragmento de código:

    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"

    El enrichKeys valor predeterminado del parámetro (factoryId,machineId) determina qué claves se capturan del almacén de estado y se agregan como atributos.

  4. Asegúrese de que cada clave que aparece en enrichKeys existe en statestore.json. Si agrega o quita claves en statestore.json, actualice el valor de default o anúlelo mediante la variable de entorno TK_CONFIGURATION_PARAMETERS.

Actualizar datos de prueba (opcional)

Puede modificar los datos de prueba de la data/ carpeta para experimentar con valores de entrada diferentes. Los datos de ejemplo incluyen lecturas de temperatura.

Compilación y ejecución del escenario de almacén de estado

  1. Presione Ctrl+Shift+P para abrir la paleta de comandos y busque Operaciones de Azure IoT: Compilar todos los operadores de flujo de datos.

  2. Seleccione release (Versión ) como modo de compilación. Espere a que la compilación finalice.

  3. Pulse Ctrl+Shift+P de nuevo y busque Operaciones de IoT de Azure: ejecutar gráfico de aplicaciones.

  4. Seleccione release como modo de ejecución.

  5. Seleccione la data carpeta del área de trabajo de VS Code para los datos de entrada. El contenedor DevX se inicia para ejecutar el gráfico con la entrada de ejemplo.

Verificación de la funcionalidad del almacén de estado

Una vez completada la ejecución del grafo:

  1. Vea los resultados en la data/output/ carpeta .

  2. Abra el archivo generado .txt para ver los datos procesados. La user properties sección de los mensajes de salida incluye los valores factoryId y machineId recuperados del almacén de estado.

  3. Compruebe los registros en data/output/logs/host-app.log para comprobar que el otel-enrich operador recuperó los valores del almacén de estado y los agregó como propiedades de usuario a los mensajes.

Compatibilidad con el registro de esquemas para módulos WASM

En este ejemplo se muestra cómo usar el registro de esquema con módulos WASM. El registro de esquema le permite validar formatos de mensaje y garantizar la coherencia de los datos en el procesamiento del flujo de datos.

Abre el área de trabajo de ejemplo del registro de esquemas

Clona el repositorio Explore IoT Operations si aún no lo has hecho.

Abra la samples/wasm/schema-registry-scenario carpeta en Visual Studio Code; para ello, seleccione Abrir > carpeta y vaya a la samples/wasm/schema-registry-scenario carpeta. Esta carpeta contiene los siguientes recursos:

  • graph.dataflow.yaml - La configuración del grafo de flujo de datos.
  • tk_schema_config.json - el esquema JSON que la aplicación anfitriona usa localmente para validar las cargas de mensajes entrantes antes de llegar a los operadores posteriores. Mantenga este archivo sincronizado con cualquier esquema que publique en su entorno de Microsoft Azure.
  • data/ - Datos de entrada de ejemplo con diferentes formatos de mensaje para las pruebas.
  • operators/filter/ - Código fuente del operador de filtro.
  • (Opcional) hostapp.env.list - La extensión de VS Code genera automáticamente una en tiempo de ejecución agregando TK_SCHEMA_CONFIG_PATH=tk_schema_config.json. Si proporciona su propio archivo de esquema, asegúrese de que la variable apunta a él.

Descripción de la configuración del esquema

Abra el tk_schema_config.json archivo para ver la definición del esquema:

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

Este esquema define un objeto JSON de nivel superior que puede contener dos propiedades numéricas: humidity (entero) y temperature (número). Agregue una matriz "required": ["humidity", "temperature"] si necesita que ambas sean obligatorias, o amplíe la sección properties a medida que evoluciona el formato de carga útil.

Las siguientes limitaciones se aplican al archivo de esquema local (tk_schema_config.json). El archivo de esquema:

  • Usa la sintaxis estándar JSON Schema draft-07, el mismo esquema preliminar admitido por el registro de esquemas de Operaciones de IoT de Azure.
  • Es, desde el punto de vista funcional, el mismo contenido que se registra en el registro de esquemas en la nube. Puede copiar y pegar entre los dos para mantener la coherencia.
  • La aplicación host hace referencia a ella a través de la variable TK_SCHEMA_CONFIG_PATHde entorno.

Actualmente, se aplican las siguientes limitaciones en el entorno de ejecución de desarrollo local:

  • Solo se carga un archivo de configuración de esquema. No está soportada la inclusión de múltiples archivos ni el escaneo de directorios.
  • $ref en archivos o direcciones URL externos no se admite localmente. Mantenga el esquema independiente. Puede usar referencias de puntero JSON internas como {"$ref":"#/components/..."}.
  • Normalmente se usan palabras clave draft-07 como type, properties, required, enum, minimum, maximum, allOf, anyOf, oneOf, not y items, y todas funcionan. El validador subyacente podría omitir características menos comunes o avanzadas como contentEncoding y contentMediaType.
  • Mantenga el tamaño de los esquemas en menos de ~1 MB para los arranques en frío rápidos.
  • Las directivas de control de versiones y evolución del esquema no se aplican localmente. Es responsable de mantenerse alineado con el sistema de registro en la nube.

Si se basa en construcciones avanzadas que no se validan localmente, valide el mismo esquema en el registro en la nube después de publicar para garantizar la paridad.

Para más información, consulte Conceptos del registro de esquemas de Azure IoT Operations.

Revisión de los datos de prueba

La data/ carpeta contiene tres archivos de prueba:

  • temperature_humidity_payload_1.json - Contiene datos de temperatura y humedad y pasa la validación. Sin embargo, el valor de humedad no es un entero como se especifica en el esquema, por lo que los datos se filtran.
  • temperature_humidity_payload_2.json - Contiene solo datos de humedad y se filtra.
  • temperature_humidity_payload_3.json - Contiene datos de temperatura y humedad y pasa la validación.

Compilación y ejecución del escenario del Registro de esquemas

  1. Presione Ctrl+Shift+P para abrir la paleta de comandos y busque Operaciones de Azure IoT: Compilar todos los operadores de flujo de datos.

  2. Seleccione release (Versión ) como modo de compilación. Espere a que la compilación finalice.

  3. Pulse Ctrl+Shift+P de nuevo y busque Operaciones de IoT de Azure: ejecutar gráfico de aplicaciones.

  4. Seleccione el archivo de gráfico graph.dataflow.yaml.

  5. Seleccione release como modo de ejecución.

  6. Seleccione la data carpeta del área de trabajo de VS Code para los datos de entrada. El contenedor DevX se inicia para ejecutar el gráfico con la entrada de ejemplo.

Comprobación de la validación del esquema

Una vez completado el procesamiento:

  1. Compruebe la data/output/ carpeta para ver los resultados.

  2. La salida contiene solo la versión procesada del temperature_humidity_payload_3.json mensaje porque se ajusta al esquema.

  3. El data/output/logs/host-app.log archivo contiene entradas de registro que indican qué mensajes se aceptan o rechazan en función de la validación del esquema.

En este ejemplo se muestra cómo el registro de esquema valida los mensajes entrantes y filtra los mensajes que no se ajustan al esquema definido.

Depuración de módulos WASM mediante la extensión de VS Code

En este ejemplo se muestra cómo depurar módulos WASM localmente mediante puntos de interrupción y el depurador integrado en VS Code.

Prerrequisitos

Complete el ejemplo de soporte del registro de esquemas para módulos WASM para configurar el área de trabajo de ejemplo.

Configuración de depuración

  1. Abra el archivo operators/filter/src/lib.rs en el área de schema-registry-scenario trabajo.

  2. Busque la filter función y establezca un punto de interrupción haciendo clic en el margen situado junto al número de línea o presionando 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
}

Compilación para la depuración

  1. Presione Ctrl+Shift+P para abrir la paleta de comandos y busque Operaciones de Azure IoT: Compilar todos los operadores de flujo de datos.

  2. Seleccione depurar como modo de compilación. Espere a que la compilación finalice.

Ejecución con la depuración habilitada

  1. Presione Ctrl+Shift+P y busque Azure IoT Operations: Run Application Graph.

  2. Seleccione el archivo de gráfico lldb-debug.graph.dataflow.yaml.

  3. Seleccione depurar como modo de ejecución.

  4. Seleccione la data carpeta del área de trabajo de VS Code para los datos de entrada. El contenedor DevX se inicia para ejecutar el gráfico con la entrada de ejemplo.

  5. Una vez que se inicie el contenedor de DevX, verá que el contenedor host-app comienza con un lldb-server para la depuración.

Se usa un archivo de grafo de depuración especial porque el depurador actual solo puede asociarse a un operador WASM personalizado en una sesión de depuración. El gráfico de depuración dedicado le permite mantener su flujo de trabajo normal graph.dataflow.yaml e impide que el depurador se conecte de manera impredecible cuando existen varios módulos.

Para crear tu propio archivo de gráfico de depuración:

  1. Copie el archivo normal graph.dataflow.yaml en un nuevo archivo. El uso del lldb- prefijo es una convención, pero el nombre es arbitrario.
  2. Quite todos los demás operadores WASM personalizados excepto el que quiera depurar.
  3. Vuelva a generar el operador de destino en modo de depuración para que los símbolos estén disponibles.
  4. Ejecute el gráfico de depuración con el modo de ejecución establecido en depurar. La extensión lanza un lldb-server y conecta VS Code automáticamente.

Depura el módulo WASM

  1. La ejecución se detiene automáticamente en el punto de interrupción establecido en la filter función .

  2. Usa la interfaz de depuración de VS Code para:

    • Inspeccione los valores de las variables en el panel Variables .
    • Recorra paso a paso el código mediante F10 o F11.
    • Vea la pila de llamadas en el panel Pila de llamadas .
    • Agregue relojes para variables o expresiones específicas.

  3. Para continuar la ejecución, presione F5 o seleccione el botón Continuar .

  4. El depurador se detiene en el punto de interrupción de cada mensaje que se está procesando, lo que le permite inspeccionar el flujo de datos.

Sugerencias de depuración

  • Use la consola de depuración para evaluar expresiones e inspeccionar el estado en tiempo de ejecución.
  • Establezca puntos de interrupción condicionales haciendo clic con el botón derecho en un punto de interrupción y agregando condiciones.
  • Use F9 para activar y desactivar los puntos de interrupción sin quitarlos.
  • El panel Variables muestra el estado actual de las variables locales y los parámetros de función.

Esta funcionalidad de depuración le permite solucionar problemas, comprender el flujo de datos y validar la lógica del módulo WASM antes de implementarla en producción.

Problemas conocidos

Configuración del flujo de datos

  • Valores booleanos en YAML: los valores booleanos deben estar entrecomillados como cadenas para evitar errores de validación. Por ejemplo, use "True" y "False" en lugar de true y false.

    Error de ejemplo al usar booleanos sin comillas:

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

  • Requisitos del módulo de Python: para usar módulos de Python, las operaciones de Azure IoT deben implementarse con el agente MQTT configurado para usar el perfil de memoria media o alta . Los módulos de Python no se pueden extraer cuando el perfil de memoria está establecido en Low o Tiny.

  • Tiempo de implementación de módulos: la extracción y la aplicación de módulos WASM pueden tardar algún tiempo, normalmente alrededor de un minuto, en función de las condiciones de red y el tamaño del módulo.

Extensión de VS Code

  • Detalles del error de compilación: cuando se produce un error en una compilación, es posible que el mensaje de error de la notificación emergente no proporcione detalles suficientes. Compruebe la salida del terminal para obtener información de error más específica.

  • Compatibilidad de Windows: en Windows, la primera vez que ejecuta una aplicación de grafos, podría ser que encuentre un error de error "error de comando con el código de salida 1". Si se produce este error, vuelva a intentar la operación y debería funcionar correctamente.

  • Estabilidad de la aplicación host: el entorno de ejecución local puede dejar de funcionar ocasionalmente y requerir reiniciar para recuperarse.

Solución de problemas

Visualización de registros

Para ver los registros del servicio de flujo de datos, ejecute el siguiente comando:

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

Para ver los registros del servicio de procesamiento de datos, ejecute el siguiente comando:

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

Para ver los registros de administración de módulos, ejecute el siguiente comando:

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

Procedimientos de recuperación

Restablecimiento de la extensión de VS Code: si la extensión de VS Code se comporta inesperadamente, intente desinstalarla y reinstalarla, reinicie VS Code.

  • Last updated on