Compartilhar via

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

O recurso de processamento de dados WASM (WebAssembly) personalizado nas Operações de IoT do Azure permite o processamento de dados de telemetria em tempo real em seu cluster de Operações IoT do Azure. Ao implantar módulos WASM personalizados, você pode definir e executar transformações de dados como parte do grafo de fluxo de dados ou do conector HTTP/REST.

Este artigo descreve como usar a extensão VS Code do Fluxo de Dados de Operações IoT do Azure para desenvolver, testar e depurar seus módulos WASM localmente antes de implantá-los em seu cluster de Operações IoT do Azure. Você aprenderá a:

  • Execute um aplicativo de grafo localmente executando um grafo predefinido com dados de exemplo para entender o fluxo de trabalho básico.
  • Crie módulos WASM personalizados criando novos operadores em Python e Rust com funcionalidade de mapa e filtro.
  • Use o repositório de estado para manter o estado no processamento de mensagens.
  • Use a validação do registro de esquema para validar formatos de mensagem usando esquemas JSON antes do processamento.
  • Depure módulos WASM usando pontos de interrupção e depuração passo a passo para desenvolvimento local.

A extensão tem suporte nas seguintes plataformas:

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

Para saber mais sobre grafos e WASM nas Operações de IoT do Azure, confira:

Pré-requisitos

Ambiente de desenvolvimento:

Imagens do 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

Usar a extensão do VS Code para executar um aplicativo de grafo localmente

Este exemplo usa um workspace de exemplo que contém todos os recursos necessários para criar e executar um aplicativo de grafo localmente usando a extensão vs code.

Abrir o workspace de exemplo no VS Code

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

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

Compilar os operadores

Pressione Ctrl+Shift+P para abrir a paleta de comandos e pesquisar por Operações do Azure IoT: Compilar Todos os Operadores de Fluxo de Dados. Selecione release como a opção de build.

Esse comando cria todos os operadores no workspace e cria arquivos .wasm na pasta operators. Você usa os .wasm arquivos para executar o aplicativo de grafo localmente.

Executar o aplicativo de grafo localmente

Pressione Ctrl+Shift+P para abrir a paleta de comandos e pesquisar por Azure IoT Operations: Run Application Graph. Selecione release como o modo de execução. Esse comando executa o aplicativo gráfico localmente utilizando o ambiente de execução local com o arquivo graph.dataflow.yaml no workspace.

Ele também faz a leitura de hostapp.env.list para definir a variável de ambiente TK_CONFIGURATION_PARAMETERS para os parâmetros de configuração do operador de fluxo de dados.

Quando você for solicitado a fornecer dados de entrada, selecione a data-and-images pasta no workspace. Esta pasta contém os arquivos de dados de entrada para o aplicativo de grafo, incluindo dados de temperatura e umidade, e algumas imagens para o módulo de instantâneo.

Aguarde até ver uma notificação do VS Code informando que os logs 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 o diretório data-and-images. Você pode abrir a output pasta no workspace para ver os arquivos de saída. O .txt arquivo com a data e a hora do nome do arquivo contém os dados processados e se parece com o 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 o aplicativo de grafo processou os dados de entrada e gerou a saída. A saída inclui dados de temperatura e umidade e os objetos detectados nas imagens.

Criar um novo grafo com módulos WASM personalizados

Este cenário mostra como criar um novo aplicativo de grafo com módulos WASM personalizados. O aplicativo de grafo 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 workspace de exemplo existente, você cria um novo workspace do zero. Esse processo permite que você aprenda a criar um novo aplicativo de grafo e programar os operadores em Python e Rust.

Restrição de nomenclatura do operador

Atualmente, não use hífens (-) ou traços inferiores (_) em nomes de operador. A extensão vs code impõe esse requisito, mas se você criar ou renomear módulos manualmente, isso causará problemas. Use nomes alfanuméricos simples para módulos como filter, map, stateenrichou schemafilter.

Criar um novo projeto de aplicativo de grafo no Python

Pressione Ctrl+Shift+P para abrir a paleta de comandos do VS Code e pesquise operações de IoT do Azure: Criar um novo aplicativo de fluxo de dados:

  1. Para a pasta, selecione uma pasta na qual você deseja criar o projeto. Você pode criar uma nova pasta para este projeto.
  2. Insira my-graph como o nome.
  3. Selecione Python como o idioma.
  4. Selecione Mapa como o tipo.
  5. Insira map como o nome.

Agora você tem um novo workspace do VS Code com a estrutura básica do projeto e os arquivos de início. Os arquivos iniciais incluem o arquivo graph.dataflow.yaml e o código-fonte do modelo do operador de mapa.

Importante

Para usar um módulo Python em uma instância implantada do Azure IoT Operations, você deve implantar a instância com o perfil de memória do agente definido como Médio ou Alto. Se você definir o perfil de memória como Baixo ou Minúsculo, a instância não poderá efetuar pull do módulo Python.

Adicionar código Python para o módulo do operador de mapa

Abra o operators/map/map.py arquivo 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

Verifique se o Docker está em execução. Em seguida, pressione Ctrl+Shift+P para abrir a Paleta de Comandos e pesquisar por Azure IoT Operations: Build All Data Flow Operators. Crie um módulo de lançamento.

O processo de build coloca o map.wasm arquivo para o map operador na operators/map/bin/release pasta.

Adicionar código Rust para o módulo do operador de filtro

Crie um novo operador pressionando Ctrl+Shift+P para abrir a paleta de comandos e pesquisar operações de IoT do Azure: criar um operador de fluxo de dados:

  1. Selecione Rust como o idioma.
  2. Selecione Filtrar como o tipo de operador.
  3. Insira filter como o nome.

Abra o operators/filter/src/lib.rs arquivo e substitua o conteúdo pelo código a seguir para filtrar valores em que 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 arquivo e adicione as seguintes dependências:

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

Verifique se o Docker está em execução. Em seguida, pressione Ctrl+Shift+P para abrir a Paleta de Comandos e pesquisar por Azure IoT Operations: Build All Data Flow Operators. Crie um módulo de lançamento.

O processo de build coloca o filter.wasm arquivo para o filter operador na operators/filter/bin/release pasta.

Executar o aplicativo de grafo localmente com dados de exemplo

Abra o arquivo graph.dataflow.yaml 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 pasta data que contém os dados de exemplo do repositório de exemplos clonados explore-iot-operations\samples\wasm\data para o workspace atual. A data pasta contém três arquivos JSON com dados de temperatura de entrada de exemplo.

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

  1. Selecione o arquivo de grafo graph.dataflow.yaml .
  2. Selecione release como o modo de execução.
  3. Selecione a pasta data que você copiou para o workspace.

O contêiner DevX é lançado para executar o grafo. O resultado processado é salvo na data/output pasta.

Para saber como implantar seus módulos WASM personalizados e grafo em sua instância de Operações IoT do Azure, consulte Implantar módulos WASM e grafos de fluxo de dados.

Suporte do repositório de estado para operadores WASM

Este exemplo mostra como usar o repositório de estado com operadores WASM. O repositório de estado permite que os operadores persistam e recuperem dados no processamento de mensagens e habilita operações com estado em seus grafos de fluxo de dados.

Abrir o workspace de exemplo do repositório de estado

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

Abra a samples/wasm/statestore-scenario pasta no Visual Studio Code selecionando Arquivo > Abrir Pasta e navegando até a 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 com suporte para repositório de estado.
  • statestore.json – Configuração do repositório de estado com pares chave-valor.
  • data/ - Dados de entrada de exemplo para teste.
  • operators/ - Código-fonte para os operadores otel-enrich e filter.

Configurar o repositório de estado

  1. Abra o statestore.json arquivo para exibir a configuração atual do repositório de estado.

  2. Você pode modificar os valores de factoryId ou machineId para teste. O parâmetro de enriquecimento faz referência a essas chaves.

  3. Abra graph.dataflow.yaml e examine a configuração de enriquecimento. As seções significativas deste arquivo são mostradas no seguinte snippet:

    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 buscadas do repositório de estado e adicionadas como atributos.

  4. Verifique se cada chave listada enrichKeys existe em statestore.json. Se você adicionar ou remover chaves em statestore.json, atualize o valor default ou substitua-o usando a variável de ambiente TK_CONFIGURATION_PARAMETERS.

Atualizar dados de teste (opcional)

Você pode modificar os dados de teste na data/ pasta para experimentar valores de entrada diferentes. Os dados de exemplo incluem leituras de temperatura.

Criar e executar o cenário do repositório de estado

  1. Pressione Ctrl+Shift+P para abrir a paleta de comandos e pesquisar por Operações do Azure IoT: Compilar Todos os Operadores de Fluxo de Dados.

  2. Selecione release como a opção de build. Aguarde a conclusão do build.

  3. Pressione Ctrl+Shift+P novamente e procure por Azure IoT Operations: Run Application Graph.

  4. Selecione release como o modo de execução.

  5. Selecione a data pasta no workspace do VS Code para seus dados de entrada. O contêiner DevX é iniciado para executar o grafo com a entrada de exemplo.

Verificar a funcionalidade do repositório de estado

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

  1. Exiba os resultados na data/output/ pasta.

  2. Abra o arquivo gerado .txt para ver os dados processados. A seção user properties das mensagens de saída inclui os valores factoryId e machineId recuperados do repositório de estado.

  3. Verifique os logs data/output/logs/host-app.log para verificar se o otel-enrich operador recuperou valores do repositório de estado e os adicionou como propriedades do usuário às mensagens.

Suporte ao registro de esquema para módulos WASM

Este exemplo mostra como usar o registro de esquema com módulos WASM. O registro de esquema permite validar formatos de mensagem e garantir a consistência dos dados no processamento do fluxo de dados.

Abrir o workspace de exemplo do registro de esquema

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

Abra a samples/wasm/schema-registry-scenario pasta no Visual Studio Code selecionando Arquivo > Abrir Pasta e navegando até a 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 o aplicativo host usa localmente para validar os conteúdos de mensagens de entrada antes que eles alcancem operadores downstream. Mantenha esse arquivo em sincronia com qualquer esquema publicado no ambiente do Microsoft Azure.
  • data/ – Dados de entrada de exemplo com formatos de mensagem diferentes para teste.
  • operators/filter/ - Código-fonte do operador de filtro.
  • (Opcional) hostapp.env.list - A extensão do VS Code gera automaticamente um em tempo de execução, adicionando TK_SCHEMA_CONFIG_PATH=tk_schema_config.json. Se você fornecer seu próprio arquivo de esquema, verifique se a variável aponta para ele.

Entender a configuração do esquema

Abra o tk_schema_config.json arquivo para exibir a definição de esquema:

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

Esse esquema define um objeto JSON de nível superior que pode conter duas propriedades numéricas: humidity (inteiro) e temperature (número). Adicione uma matriz "required": ["humidity", "temperature"] se você precisar torná-las necessárias ou estender a seção properties conforme o formato do seu payload evoluir.

As limitações a seguir se aplicam ao arquivo de esquema local (tk_schema_config.json). O arquivo de esquema:

  • Usa a sintaxe padrão do JSON Schema draft-07, o mesmo rascunho suportado pelo registro de esquema de Operações IoT do Azure.
  • É funcionalmente o mesmo conteúdo que você registra no registro de esquema de nuvem. Você pode copiar e colar entre os dois para se manter consistente.
  • É referenciado pelo aplicativo host por meio da variável TK_SCHEMA_CONFIG_PATHde ambiente.

Atualmente, as seguintes limitações se aplicam no runtime de desenvolvimento local:

  • Apenas um arquivo de configuração de esquema é carregado. Não há suporte para inclusão de múltiplos arquivos ou verificação de diretório.
  • $ref não há suporte local para arquivos ou URLs externos. Mantenha o esquema autossuficiente. Você pode usar referências de ponteiro JSON internas, como {"$ref":"#/components/..."}.
  • Palavras-chave de rascunho-07 comumente usadas como type, properties, required, enum, minimum, maximum, allOf, anyOf, oneOf, not e items funcionam todas. O validador subjacente pode ignorar recursos menos comuns ou avançados como contentEncoding e contentMediaType.
  • Mantenha o tamanho de seus esquemas em menos de ~1 MB para inicializações a frio rápidas.
  • As políticas de evolução de versionamento e de esquema não são impostas localmente. Você é responsável por se manter alinhado com o registro de nuvem.

Se você depender de constructos avançados que falham na validação localmente, valide o mesmo esquema no registro de nuvem após a publicação para garantir a paridade.

Para saber mais, confira os conceitos do Registro de esquema de Operações IoT do Azure.

Examinar os dados de teste

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

  • temperature_humidity_payload_1.json - Contém dados de temperatura e umidade e passa na validação. No entanto, o valor da umidade não é um inteiro conforme especificado no esquema, portanto, os dados são filtrados.
  • temperature_humidity_payload_2.json - Contém apenas dados de umidade e é filtrado.
  • temperature_humidity_payload_3.json - Contém dados de temperatura e umidade e passa na validação.

Criar e executar o cenário do registro de esquema

  1. Pressione Ctrl+Shift+P para abrir a paleta de comandos e pesquisar por Operações do Azure IoT: Compilar Todos os Operadores de Fluxo de Dados.

  2. Selecione release como a opção de build. Aguarde a conclusão do build.

  3. Pressione Ctrl+Shift+P novamente e procure por Azure IoT Operations: Run Application Graph.

  4. Selecione o arquivo de grafo graph.dataflow.yaml .

  5. Selecione release como o modo de execução.

  6. Selecione a data pasta no workspace do VS Code para seus dados de entrada. O contêiner DevX é iniciado para executar o grafo com a entrada de exemplo.

Verificar a validação do esquema

Após a conclusão do processamento:

  1. Verifique a data/output/ pasta para obter os resultados.

  2. A saída contém apenas a versão processada da temperature_humidity_payload_3.json mensagem porque está em conformidade com o esquema.

  3. O data/output/logs/host-app.log arquivo contém entradas de log que indicam quais mensagens são aceitas ou rejeitadas com base na validação do esquema.

Este exemplo mostra como o registro de esquema valida mensagens de entrada e filtra mensagens que não estão em conformidade com o esquema definido.

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

Este exemplo mostra como depurar módulos WASM localmente usando pontos de interrupção e o depurador integrado do VS Code.

Pré-requisitos

Finalize o exemplo de suporte do Registro de Esquema para módulos WASM para configurar o workspace de exemplo.

Configurar a depuração

  1. Abra o arquivo operators/filter/src/lib.rs no schema-registry-scenario workspace.

  2. 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
}

Compilar para depuração

  1. Pressione Ctrl+Shift+P para abrir a paleta de comandos e pesquisar por Operações do Azure IoT: Compilar Todos os Operadores de Fluxo de Dados.

  2. Selecione depurar como o modo de build. Aguarde a conclusão do build.

Executar com depuração ativada

  1. Pressione Ctrl+Shift+P e pesquise por Operações do Azure IoT: executar o aplicativo Graph.

  2. Selecione o arquivo de grafo lldb-debug.graph.dataflow.yaml .

  3. Selecione depurar como o modo de execução.

  4. Selecione a data pasta no workspace do VS Code para seus dados de entrada. O contêiner DevX é iniciado para executar o grafo com a entrada de exemplo.

  5. Depois que o contêiner DevX for iniciado, você verá o contêiner do aplicativo host iniciar com um lldb-server para depuração.

Você utiliza um arquivo gráfico de depuração especial porque o depurador atual só pode se conectar a um operador WASM personalizado em uma sessão de depuração. O grafo de depuração dedicado permite manter seu graph.dataflow.yaml normal e impede que o depurador se anexe de forma imprevisível quando há vários módulos.

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

  1. Copie seu regular graph.dataflow.yaml para um novo arquivo. Usar o lldb- prefixo é uma convenção, mas o nome é arbitrário.
  2. Remova todos os outros operadores WASM personalizados, exceto aquele que você deseja depurar.
  3. Recompile o operador de destino no modo de depuração para que os símbolos estejam disponíveis.
  4. Execute o grafo de depuração com o modo de execução definido para depurar. A extensão inicia um lldb-server e anexa o VS Code automaticamente.

Depurar o módulo WASM

  1. A execução é interrompida automaticamente no ponto de interrupção definido na filter função.

  2. Use a interface de depuração do VS Code para:

    • Inspecione valores de variáveis no painel Variáveis .
    • Percorrer o código usando F10 ou F11.
    • Exiba a pilha de chamadas no painel Pilha de Chamadas .
    • Adicione relógios para variáveis ou expressões específicas.

  3. Continue a execução pressionando F5 ou selecionando o botão Continuar .

  4. O depurador para no ponto de interrupção de cada mensagem que está sendo processada, permitindo que você inspecione o fluxo de dados.

Dicas de depuração

  • Use o Console de Depuração para avaliar expressões e inspecionar o estado do runtime.
  • Defina pontos de interrupção condicionais clicando com o botão direito do mouse em um ponto de interrupção e adicionando condições.
  • Use F9 para ativar e desativar pontos de interrupção sem removê-los.
  • O painel Variáveis mostra o estado atual de variáveis locais e parâmetros de função.

Essa funcionalidade de depuração permite que você solucione problemas, entenda o fluxo de dados e valide a lógica do módulo WASM antes de implantar na produção.

Problemas conhecidos

Configuração do fluxo de dados

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

    Erro de exemplo ao usar boolianos não citados:

    * 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 do módulo Python: para usar módulos do Python, as Operações de IoT do Azure devem ser implantadas com o agente MQTT configurado para usar o perfil de memória Média ou Alta . Os módulos python não podem ser puxados quando o perfil de memória é definido como Baixo ou Minúsculo.

  • Tempo de implantação do módulo: puxar e aplicar módulos WASM pode levar algum tempo, normalmente em torno de um minuto, dependendo das condições de rede e do tamanho do módulo.

Extensão do VS Code

  • Detalhes do erro de build: Quando um build falha, a mensagem de erro na notificação pop-up pode não fornecer detalhes suficientes. Verifique a saída do terminal para obter informações de erro mais específicas.

  • Compatibilidade do Windows: no Windows, na primeira vez em que você executa um aplicativo de grafo, você pode encontrar um erro "o comando falhou com o código de saída 1". Se esse erro ocorrer, repita a operação e ela deverá funcionar corretamente.

  • Estabilidade do aplicativo host: o ambiente de execução local pode ocasionalmente parar de funcionar e exigir a reinicialização para recuperação.

Resolução de problemas

Exibindo logs

Para exibir logs 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 exibir os logs do serviço de processamento de dados, execute o seguinte comando:

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

Para exibir os logs de gerenciamento 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

Redefinição de extensão do VS Code: se a extensão do VS Code se comportar inesperadamente, tente desinstalá-la e reinstalá-la e reinicie o VS Code.

  • Last updated on