Construir módulos WASM para fluxos de dados no VS Code

A funcionalidade personalizada de processamento de dados WebAssembly (WASM) no Azure IoT Operations permite o processamento de dados de telemetria em tempo real dentro do seu cluster Azure IoT Operations. Ao implementar módulos WASM personalizados, pode definir e executar transformações de dados como parte do seu grafo de fluxo de dados ou conector HTTP/REST.

Este artigo descreve como usar a extensão Azure IoT Operations Data Flow VS Code para desenvolver, testar e depurar localmente os seus módulos WASM antes de os implementar no seu cluster Azure IoT Operations. Você aprenderá a:

Execute uma aplicação de grafos localmente executando um grafo pré-construído com dados de exemplo para compreender o fluxo de trabalho básico.
Crie módulos WASM personalizados construindo novos operadores em Python e Rust com funcionalidade de mapas e filtros.
Utilize a memória de estados para manter o estado ao longo do processamento de mensagens.
Use a validação do registo de esquemas para validar formatos de mensagens usando esquemas JSON antes do processamento.
Depura módulos WASM usando pontos de interrupção e depuração passo-passo para desenvolvimento local.

A extensão é suportada nas seguintes plataformas:

Linux
Subsistema Windows para Linux (WSL)
Windows

Para saber mais sobre grafos e WASM no Azure IoT Operations, veja:

Pré-requisitos

Ambiente de desenvolvimento:

Código do Visual Studio
(Opcional) RedHat extensão YAML para VS Code
Azure IoT Operations Data Flow extension for VS Code.
Extensão CodeLLDB para VS Code que permite a depuração de módulos WASM
Azure CLI
ORAS CLI
Docker

Imagens 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

Use a extensão VS Code para executar uma aplicação de grafo localmente

Este exemplo utiliza um espaço de trabalho de exemplo que contém todos os recursos necessários para construir e executar localmente uma aplicação de grafo usando a extensão VS Code.

Abrir o espaço de trabalho de exemplo no VS Code

Clone o repositório Explore IoT Operations , caso ainda não o tenha feito.

Abra a samples/wasm pasta no Visual Studio Code selecionando Ficheiro > Abrir Pasta e navegando até à samples/wasm pasta.

Construa os operadores

Pressione Ctrl+Shift+P para abrir a paleta de comandos e procure por Azure IoT Operations: Build All Data Flow Operators. Seleciona release como modo de construção.

Este comando constrói todos os operadores no espaço de trabalho e cria .wasm ficheiros na operators pasta. Usas os .wasm ficheiros para executar a aplicação de grafos localmente.

Executar a aplicação do grafo localmente

Pressione Ctrl+Shift+P para abrir a paleta de comandos e procure por Azure IoT Operations: Run Application Graph. Seleciona release como modo de corrida. Este comando executa a aplicação do grafo localmente, utilizando o ambiente de execução local com o graph.dataflow.yaml ficheiro no espaço de trabalho.

Também lê de hostapp.env.list para definir a variável TK_CONFIGURATION_PARAMETERS de ambiente para os parâmetros de configuração do operador de fluxo de dados.

Quando te pedirem dados de entrada, seleciona a data-and-images pasta no espaço de trabalho. Esta pasta contém os ficheiros de dados de entrada para a aplicação de grafos, incluindo dados de temperatura e humidade, e algumas imagens para o módulo de snapshot.

Espere até ver uma notificação do VS Code a indicar que os registos estão prontos: Log files for the run can be found at ...\wasm\data-and-images\output\logs.

A saída está localizada na output pasta sob a data-and-images pasta. Podes abrir a output pasta no espaço de trabalho para ver os ficheiros de saída. O .txt ficheiro com a data e hora do nome do ficheiro contém os dados processados, e assemelha-se ao seguinte exemplo:

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

A saída mostra que a aplicação de grafos processou os dados de entrada e gerou a saída. A saída inclui dados de temperatura e humidade, bem como os objetos detetados nas imagens.

Crie um novo grafo com módulos WASM personalizados

Este cenário mostra-lhe como criar uma nova aplicação de grafos com módulos WASM personalizados. A aplicação dos grafos consiste em dois operadores: um map operador que converte valores de temperatura de Fahrenheit para Celsius, e um filter operador que filtra mensagens com valores de temperatura acima de 500°C.

Em vez de usar um espaço de trabalho de exemplo existente, cria um novo espaço de trabalho do zero. Este processo permite-lhe aprender a criar uma nova aplicação de grafos e programar os operadores em Python e Rust.

Restrição de nomenclatura de operadores

Atualmente, não use hífenes (-) ou sublinhados (_) nos nomes dos operadores. A extensão VS Code impõe este requisito, mas se criar ou renomear módulos manualmente, isso causa problemas. Use nomes alfanuméricos simples para módulos como filter, map, stateenrich, ou schemafilter.

Criar um novo projeto de aplicação de grafos em Python

Pressione Ctrl+Shift+P para abrir a paleta de comandos VS Code e procure Azure IoT Operations: Criar uma nova Aplicação de Fluxo de Dados:

Para a pasta, seleciona uma pasta onde queres criar o projeto. Pode criar uma nova pasta para este projeto.
Inscreva my-graph como nome.
Seleciona Python como linguagem.
Selecione Mapa como tipo.
Inscreva map como nome.

Agora tens um novo espaço de trabalho no VS Code com a estrutura básica do projeto e ficheiros iniciais. Os ficheiros iniciais incluem o graph.dataflow.yaml ficheiro e o código-fonte do modelo do operador do mapa.

Importante

Para usar um módulo Python numa instância Azure IoT Operations implementada, deve implementar a instância com o perfil de memória do broker definido para Médio ou Alto. Se definires o perfil de memória para Low ou Tiny, a instância não consegue puxar o módulo Python.

Adicionar código Python para o módulo de operadores de mapa

Abra o operators/map/map.py ficheiro e substitua o conteúdo pelo seguinte código para converter um valor de temperatura de entrada de Fahrenheit para 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

Certifica-te de que o Docker está a funcionar. Depois, pressione Ctrl+Shift+P para abrir a paleta de comandos e procure por Azure IoT Operations: Build All Data Flow Operators. Cria um módulo de lançamento .

O processo de compilação coloca o map.wasm ficheiro do map operador na operators/map/bin/release pasta.

Adicionar código Rust para o módulo de operadores de filtro

Crie um novo operador pressionando Ctrl+Shift+P para abrir a paleta de comandos e procure Azure IoT Operations: Criar operador de fluxo de dados:

Selecione Rust como linguagem.
Selecione Filter como tipo de operador.
Inscreva filter como nome.

Abra o operators/filter/src/lib.rs ficheiro e substitua o conteúdo pelo seguinte código para filtrar valores onde a temperatura está acima 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 o operators/filter/Cargo.toml ficheiro e adicione as seguintes dependências:

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

O processo de compilação coloca o filter.wasm ficheiro do filter operador na operators/filter/bin/release pasta.

Executar a aplicação do grafo localmente com dados de exemplo

Abra o graph.dataflow.yaml arquivo e substitua o conteúdo pelo seguinte código:

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 a data pasta que contém os dados de amostra do repositório explore-iot-operations\samples\wasm\data de amostras clonadas para o espaço de trabalho atual. A data pasta contém três ficheiros JSON com dados de amostra de temperatura de entrada.

Pressione Ctrl+Shift+P para abrir a paleta de comandos e procure por Azure IoT Operations: Run Application Graph:

Selecione o graph.dataflow.yaml ficheiro do gráfico.
Seleciona release como modo de corrida.
Selecione a data pasta que copiou para o espaço de trabalho.

O contentor DevX inicia-se para executar o gráfico. O resultado processado é guardado na data/output pasta.

Para saber como implementar os seus módulos WASM personalizados e grafos para a sua instância Azure IoT Operations, consulte Deploy WASM modules and data flow graphs.

Suporte para armazenamento de estado para operadores WASM

Este exemplo mostra como usar a loja de estado com operadores WASM. O armazenamento de estado permite que os operadores persistam e recuperem dados durante o processamento de mensagens, e permite operações com estado nos seus grafos de fluxo de dados.

Abrir o exemplo de espaço de trabalho de armazenamento de estado

Clone o repositório Explore IoT Operations , caso ainda não o tenha feito.

Abra a samples/wasm/statestore-scenario pasta no Visual Studio Code selecionando Ficheiro > Abrir Pasta e navegando até à samples/wasm/statestore-scenario pasta. Esta pasta contém os seguintes recursos:

graph.dataflow.yaml - A configuração do grafo de fluxo de dados com um operador de armazenamento de estados ativado.
statestore.json - Configuração de armazenamento de estados com pares chave-valor.
data/ - Amostra de dados de entrada para testes.
operators/ - Código-fonte para os operadores otel-enrich e filter.

Configurar a memória de estados

Abra o statestore.json ficheiro para visualizar a configuração atual da memória de estado.
Pode modificar os valores de factoryId ou machineId para testar. O parâmetro de enriquecimento refere-se a estas chaves.

Abra graph.dataflow.yaml e veja a configuração do enriquecimento. As secções significativas deste ficheiro são mostradas no seguinte excerto:

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"

O enrichKeys valor padrão do parâmetro (factoryId,machineId) determina quais chaves são obtidas do store de estado e adicionadas como atributos.

Certifique-se de que cada chave listada em enrichKeys existe em statestore.json. Se adicionares ou removeres chaves em statestore.json, atualiza o valor de default ou substitui-o usando a variável de ambiente TK_CONFIGURATION_PARAMETERS.

Atualizar dados de teste (opcional)

Podes modificar os dados de teste na data/ pasta para experimentar diferentes valores de entrada. Os dados da amostra incluem leituras de temperatura.

Construir e executar o cenário de armazenamento de estado

Pressione Ctrl+Shift+P para abrir a paleta de comandos e procure por Azure IoT Operations: Build All Data Flow Operators.
Seleciona release como modo de construção. Aguarde a conclusão da compilação.
Pressione Ctrl+Shift+P novamente e procure por Azure IoT Operations: Run Application Graph.
Seleciona release como modo de corrida.
Selecione a data pasta no seu espaço de trabalho VS Code para os seus dados de entrada. O contentor DevX inicia-se para executar o grafo com a entrada da amostra.

Verificar a funcionalidade do armazenamento de estado

Após a conclusão da execução do grafo:

Veja os resultados na data/output/ pasta.
Abra o ficheiro gerado .txt para ver os dados processados. A user properties secção das mensagens de saída inclui os valores factoryId e machineId recuperados da loja de estados.
Verifique os registos em data/output/logs/host-app.log para confirmar que o otel-enrich operador recuperou valores do armazenamento de estado e os adicionou como propriedades de utilizador às mensagens.

Suporte ao registo de esquemas para módulos WASM

Este exemplo mostra-lhe como usar o registo de esquemas com módulos WASM. O registo de esquemas permite-lhe validar os formatos das mensagens e garantir a consistência dos dados no processamento do seu fluxo de dados.

Abrir o espaço de trabalho de exemplo do registo de esquemas

Clone o repositório Explore IoT Operations , caso ainda não o tenha feito.

Abra a samples/wasm/schema-registry-scenario pasta no Visual Studio Code selecionando Ficheiro > Abrir Pasta e navegando até à samples/wasm/schema-registry-scenario pasta. Esta pasta contém os seguintes recursos:

graph.dataflow.yaml - A configuração do grafo de fluxo de dados.
tk_schema_config.json - O esquema JSON que a aplicação anfitriã utiliza localmente para validar as cargas úteis das mensagens recebidas antes de chegarem aos operadores a jusante. Mantenha este ficheiro sincronizado com qualquer esquema que publique no seu ambiente Microsoft Azure.
data/ - Amostrar dados de entrada com diferentes formatos de mensagem para testes.
operators/filter/ - Código-fonte para o operador de filtro.
(Opcional) hostapp.env.list - A extensão VS Code gera automaticamente um em tempo de execução adicionando TK_SCHEMA_CONFIG_PATH=tk_schema_config.json. Se forneceres o teu próprio ficheiro de esquema, certifica-te de que a variável aponta para ele.

Compreender a configuração do esquema

Abra o tk_schema_config.json ficheiro para visualizar a definição do esquema:

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

Este esquema define um objeto JSON de topo que pode conter duas propriedades numéricas: humidity (inteiro) e temperature (número). Adiciona uma matriz "required": ["humidity", "temperature"] se for necessário tornar ambos como obrigatórios, ou estende a secção properties à medida que o formato do carregamento evolui.

As seguintes limitações aplicam-se ao ficheiro de esquema local (tk_schema_config.json). O ficheiro de esquema:

Utiliza a sintaxe padrão JSON Schema draft-07, a mesma versão suportada pelo registo de esquemas Azure IoT Operations.
É funcionalmente o mesmo conteúdo que registas no registo do esquema da nuvem. Podes copiar e colar entre os dois para manteres a consistência.
É referenciado pela aplicação anfitriã através da variável TK_SCHEMA_CONFIG_PATHde ambiente .

Atualmente, aplicam-se as seguintes limitações no tempo de execução do desenvolvimento local:

Apenas um ficheiro de configuração de esquema é carregado. A inclusão de múltiplos ficheiros ou a varredura de diretórios não é suportada.
$ref para ficheiros externos ou URLs não é suportado localmente. Mantenha o esquema autossuficiente. Podes usar referências internas de ponteiro JSON como {"$ref":"#/components/..."}.
Palavras-chave comumente usadas no draft-07 como type, properties, required, enum, minimum, maximum, allOfanyOfoneOfnote items todas funcionam. O validador subjacente pode ignorar funcionalidades menos comuns ou avançadas como contentEncoding e contentMediaType.
Mantém o tamanho dos teus esquemas para menos de ~1 MB para arranques rápidos a frio.
As políticas de versionamento e evolução de esquemas não são aplicadas localmente. És responsável por te manteres alinhado com o registo da nuvem.

Se depender de construções avançadas que falham a validação localmente, valide o mesmo esquema contra o registo na cloud após a publicação para garantir a paridade.

Para saber mais, consulte o registo de esquemas do Azure IoT Operations.

Rever os dados do teste

A data/ pasta contém três ficheiros de teste:

temperature_humidity_payload_1.json - Contém dados de temperatura e humidade e passa a validação. No entanto, o valor de humidade não é um inteiro como especificado no esquema, por isso os dados são filtrados.
temperature_humidity_payload_2.json - Contém apenas dados de humidade e é filtrado.
temperature_humidity_payload_3.json - Contém dados de temperatura e humidade e passa a validação.

Construir e executar o cenário do registo de esquemas

Pressione Ctrl+Shift+P para abrir a paleta de comandos e procure por Azure IoT Operations: Build All Data Flow Operators.
Seleciona release como modo de construção. Aguarde a conclusão da compilação.
Pressione Ctrl+Shift+P novamente e procure por Azure IoT Operations: Run Application Graph.
Selecione o graph.dataflow.yaml ficheiro do gráfico.
Seleciona release como modo de corrida.
Selecione a data pasta no seu espaço de trabalho VS Code para os seus dados de entrada. O contentor DevX inicia-se para executar o grafo com a entrada da amostra.

Verificar a validação do esquema

Após a conclusão do processamento:

Consulta a data/output/ pasta para ver os resultados.
A saída contém apenas a versão processada da temperature_humidity_payload_3.json mensagem porque esta está em conformidade com o esquema.
O data/output/logs/host-app.log ficheiro contém entradas de registo que indicam quais as mensagens aceites ou rejeitadas com base na validação do esquema.

Este exemplo mostra como o registo de esquemas valida as mensagens recebidas e filtra as mensagens que não cumprem o esquema definido.

Depurar módulos WASM usando a extensão VS Code

Este exemplo mostra-lhe como depurar módulos WASM localmente usando pontos de interrupção e o depurador integrado no Visual Studio Code.

Pré-requisitos

Complete o exemplo de suporte ao registo de esquemas para módulos WASM para configurar o espaço de trabalho de exemplo.

Configurar a depuração

Abra o ficheiro operators/filter/src/lib.rs no schema-registry-scenario espaço de trabalho.

Localize a filter função e defina um ponto de interrupção clicando na margem ao lado do número da linha ou pressionando 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
}

Compilação para depuração

Pressione Ctrl+Shift+P para abrir a paleta de comandos e procure por Azure IoT Operations: Build All Data Flow Operators.
Selecione depuração como modo de compilação. Aguarde a conclusão da compilação.

Executar com a depuração ativada

Pressione Ctrl+Shift+P e procure Azure IoT Operations: Run Application Graph.
Selecione o lldb-debug.graph.dataflow.yaml ficheiro do gráfico.
Selecione debug como modo de execução.
Selecione a data pasta no seu espaço de trabalho VS Code para os seus dados de entrada. O contentor DevX inicia-se para executar o grafo com a entrada da amostra.
Depois do lançamento do contentor DevX, é possível observar que o contentor da aplicação host-app começa com um lldb-server para depuração.

Utiliza-se um ficheiro de grafo de depuração especial porque o depurador atual só pode ser associado a um operador WASM personalizado numa sessão de depuração. O grafo dedicado de depuração permite-lhe manter o seu normal graph.dataflow.yaml e impede que o depurador se anexe de forma imprevisível quando existem múltiplos módulos.

Para criar o seu próprio ficheiro de grafo de depuração:

Copie o seu habitual graph.dataflow.yaml para um novo ficheiro. Usar o lldb- prefixo é uma convenção, mas o nome é arbitrário.
Remove todos os outros operadores WASM personalizados, exceto aquele que queres depurar.
Reconstrua o operador de destino em modo de depuração para que os símbolos estejam disponíveis.
Executa o grafo de depuração com o modo de execução definido para depurar. A extensão lança lldb-server e conecta automaticamente ao VS Code.

Depurar o módulo WASM

A execução para automaticamente no ponto de interrupção que definiste na filter função.
Utilize a interface de depuração do VS Code para:
- Inspecionar os valores das variáveis no painel de Variáveis .
- Percorra o código usando F10 ou F11.
- Veja a pilha de chamadas no painel Pilha de Chamadas.
- Adiciona relógios para variáveis ou expressões específicas.
Continue a execução pressionando F5 ou selecionando o botão Continuar .
O depurador para no ponto de interrupção de cada mensagem a ser processada, permitindo-lhe inspecionar o fluxo de dados.

Dicas de depuração

Use a Consola de Depuração para avaliar expressões e inspecionar o estado de execução.
Defina pontos de interrupção condicionais clicando com o botão direito num ponto de interrupção e adicionando condições.
Uso F9 para ativar e desligar os pontos de interrupção sem os remover.
O painel de Variáveis mostra o estado atual das variáveis locais e dos parâmetros da função.

Esta capacidade de depuração permite-lhe resolver problemas, compreender o fluxo de dados e validar a lógica do seu módulo WASM antes de implementar para produção.

Problemas conhecidos

Configuração do fluxo de dados

Valores booleanos no YAML: Os valores booleanos devem ser citados como cadeias para evitar erros de validação. Por exemplo, use "True" e "False" em vez de true e false.

Exemplo de erro ao usar booleanos sem aspas:

* 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 para módulos Python: Para utilizar módulos Python, o Azure IoT Operations deve ser implementado com o broker MQTT configurado para usar o perfil de memória Média ou Alta . Módulos em Python não podem ser puxados quando o perfil de memória está definido para Baixo ou Pequeno.
Tempo de implementação dos módulos: A retirada e aplicação dos módulos WASM pode demorar algum tempo, tipicamente cerca de um minuto, dependendo das condições da rede e do tamanho do módulo.

Extensão VS Code

Detalhes do erro de compilação: Quando uma compilação falha, a mensagem de erro na notificação pop-up pode não fornecer detalhes suficientes. Verifique a saída do terminal para informações de erro mais específicas.
Compatibilidade com Windows: No Windows, na primeira vez que executa uma aplicação de grafos, pode encontrar um erro "comando falhou com código de saída 1." Se este erro ocorrer, tente novamente a operação e deverá funcionar corretamente.
Estabilidade da aplicação anfitriã: O ambiente de execução local pode, por vezes, deixar de funcionar e necessitar de reiniciar para recuperar.

Solução de problemas

Registos de visualização

Para visualizar os registos de serviço de fluxo de dados, execute o seguinte comando:

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

Para visualizar registos de serviços de processamento de dados, execute o seguinte comando:

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

Para visualizar registos de gestão de módulos, execute o seguinte comando:

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

Procedimentos de recuperação

Reinício da extensão VS Code: Se a extensão VS Code se comportar de forma inesperada, tente desinstalá-la e reinstalá-la, depois reinicie o VS Code.

Feedback

Esta página foi útil?

Last updated on 2025-12-10

Partilhar via

Construir módulos WASM para fluxos de dados no VS Code

Pré-requisitos

Use a extensão VS Code para executar uma aplicação de grafo localmente

Abrir o espaço de trabalho de exemplo no VS Code

Construa os operadores

Executar a aplicação do grafo localmente

Crie um novo grafo com módulos WASM personalizados

Restrição de nomenclatura de operadores

Criar um novo projeto de aplicação de grafos em Python

Adicionar código Python para o módulo de operadores de mapa

Adicionar código Rust para o módulo de operadores de filtro

Executar a aplicação do grafo localmente com dados de exemplo

Suporte para armazenamento de estado para operadores WASM

Abrir o exemplo de espaço de trabalho de armazenamento de estado

Configurar a memória de estados

Atualizar dados de teste (opcional)

Construir e executar o cenário de armazenamento de estado

Verificar a funcionalidade do armazenamento de estado

Suporte ao registo de esquemas para módulos WASM

Abrir o espaço de trabalho de exemplo do registo de esquemas

Compreender a configuração do esquema

Rever os dados do teste

Construir e executar o cenário do registo de esquemas

Verificar a validação do esquema

Depurar módulos WASM usando a extensão VS Code

Pré-requisitos

Configurar a depuração

Compilação para depuração

Executar com a depuração ativada

Depurar o módulo WASM

Dicas de depuração

Problemas conhecidos

Configuração do fluxo de dados

Extensão VS Code

Solução de problemas

Registos de visualização

Procedimentos de recuperação

Feedback

Recursos adicionais