Configurar definições de grafo do WASM (WebAssembly) para grafos e conectores de fluxo de dados

As definições de grafo são centrais para o desenvolvimento de WASM porque definem como seus módulos se conectam a fluxos de dados e conectores. Entender a relação entre definições de grafo e grafos ou conectores de fluxo de dados ajuda você a se desenvolver com eficiência.

Este artigo foca na criação e configuração das definições de grafo em YAML. Para obter informações sobre como implantar e testar grafos de fluxo de dados, consulte módulos de implantação de WASM (WebAssembly) e definições de grafo.

Estrutura da definição de grafo

As definições de grafo seguem um esquema JSON formal que valida a estrutura e garante compatibilidade. A configuração inclui:

• Requisitos do módulo para compatibilidade de versão da API e da biblioteca host
• Configurações do módulo para parâmetros de tempo de execução e personalização de operadores
• Operações que definem os nós de processamento em seu fluxo de trabalho
• Conexões que especificam o roteamento do fluxo de dados entre operações
• Esquemas para validação de dados opcional

Estrutura básica do grafo

metadata:
  $schema: "https://www.schemastore.org/aio-wasm-graph-config-1.0.0.json"
  name: "Simple graph"
  description: "A simple graph with a source, a map module, and a sink"
  version: "1.0.0"
  vendor: "Microsoft"

moduleRequirements:
  apiVersion: "1.1.0"
  runtimeVersion: "1.1.0"

operations:
  - operationType: "source"
    name: "data-source"
  - operationType: "map"
    name: "my-operator/map"
    module: "my-operator:1.0.0"
  - operationType: "sink"
    name: "data-sink"

connections:
  - from: { name: "data-source" }
    to: { name: "my-operator/map" }
  - from: { name: "my-operator/map" }
    to: { name: "data-sink" }

Compatibilidade entre versões

A moduleRequirements seção garante compatibilidade usando versionamento semântico:

moduleRequirements:
  apiVersion: "1.1.0"          # WASI API version for interface compatibility
  runtimeVersion: "1.1.0"     # Runtime version providing runtime support
  features:                    # Optional features required by modules
    - name: "wasi-nn"

Exemplo 1: Definição de grafo simples

A definição de grafo simples demonstra um pipeline básico de três etapas que converte dados de temperatura de Fahrenheit para Celsius:

metadata:
  name: "Simple graph"
  description: "A graph that transforms temperature from Fahrenheit to Celsius"
  version: "1.0.0"
  $schema: "https://www.schemastore.org/aio-wasm-graph-config-1.0.0.json"
  vendor: "Microsoft"

moduleRequirements:
  apiVersion: "1.1.0"
  runtimeVersion: "1.1.0"

moduleConfigurations:
  - name: module-temperature/map
    parameters:
      key1:
        name: key2
        description: key2
operations:
  - operationType: "source"
    name: "source"

  - operationType: "map"
    name: "module-temperature/map"
    module: "temperature:1.0.0"

  - operationType: "sink"
    name: "sink"

connections:
  - from:
      name: "source"
    to:
      name: "module-temperature/map"

  - from:
      name: "module-temperature/map"
    to:
      name: "sink"

Para obter instruções de implantação passo a passo, consulte Módulos de Implantação de WebAssembly (WASM) e definições de grafo. Para experimentar um fluxo de dados que usa este exemplo, consulte Exemplo 1: implantação básica com um módulo WASM.

Como o grafo simples funciona

Este grafo cria um pipeline de processamento de dados simples:

1. Operação de origem: Recebe dados de temperatura do ponto de extremidade de origem do fluxo de dados
2. Operação de mapa: Processa os dados com o módulo WASM de temperatura (temperature:1.0.0)
3. Operação de destino: Envia os dados convertidos para o ponto de extremidade de destino do fluxo de dados

O módulo de temperatura converte Fahrenheit para Celsius usando a fórmula padrão (F - 32) × 5/9 = C.

Formato de entrada:

{"temperature": {"value": 100.0, "unit": "F"}}

Formato de saída:

{"temperature": {"value": 37.8, "unit": "C"}}

Exemplo 2: Definição de grafo complexa

A definição de grafo complexa demonstra um fluxo de trabalho de processamento sofisticado para múltiplos sensores, que lida com dados de temperatura, umidade e imagens com análises avançadas:

metadata:
  name: "Complex graph"
  description: "A graph that processes temperature and humidity data from sensors, along with snapshot data. The graph performs filtering, accumulation, and enrichment operations before sending the processed data to the sink."
  version: "1.0.0"
  $schema: "https://www.schemastore.org/aio-wasm-graph-config-1.0.0.json"
  vendor: "Microsoft"

moduleRequirements:
  apiVersion: "1.1.0"
  runtimeVersion: "1.1.0"

moduleConfigurations:
  - name: module-temperature/map
    parameters:
      key1:
        name: key2
        description: key2
  - name: module-snapshot/branch
    parameters:
      snapshot_topic:
        name: snapshot_topic
        description: Transform app snapshot_topic in snapshot branch's init routine
operations:
  - operationType: "source"
    name: "source"

  - operationType: delay
    name: module-window/delay
    module: window:1.0.0
  - operationType: "map"
    name: "module-format/map"
    module: "format:1.0.0"
  - operationType: map
    name: module-snapshot/map
    module: snapshot:1.0.0
  - operationType: branch
    name: module-snapshot/branch
    module: snapshot:1.0.0
  - operationType: accumulate
    name: module-snapshot/accumulate
    module: snapshot:1.0.0
  - operationType: map
    name: module-temperature/map
    module: temperature:1.0.0
  - operationType: branch
    name: module-temperature/branch
    module: temperature:1.0.0
  - operationType: filter
    name: module-temperature/filter
    module: temperature:1.0.0
  - operationType: accumulate
    name: module-temperature/accumulate
    module: temperature:1.0.0
  - operationType: accumulate
    name: module-humidity/accumulate
    module: humidity:1.0.0
  - operationType: concatenate
    name: concatenate1
    module:
  - operationType: accumulate
    name: module-collection/accumulate
    module: collection:1.0.0
  - operationType: map
    name: module-enrichment/map
    module: enrichment:1.0.0

  - operationType: "sink"
    name: "sink"

connections:
  - from:
      name: source
    to:
      name: module-window/delay

  - from:
      name: module-window/delay
    to:
      name: module-snapshot/branch

  - from:
      name: module-snapshot/branch
      arm: "False"
    to:
      name: module-temperature/branch

  - from:
      name: module-snapshot/branch
      arm: "True"
    to:
      name: module-format/map

  - from:
      name: module-format/map
    to:
      name: module-snapshot/map

  - from:
      name: module-snapshot/map
    to:
      name: module-snapshot/accumulate

  - from:
      name: module-snapshot/accumulate
    to:
      name: concatenate1

  - from:
      name: module-temperature/branch
      arm: "True"
    to:
      name: module-temperature/map

  - from:
      name: module-temperature/branch
      arm: "False"
    to:
      name: module-humidity/accumulate

  - from:
      name: module-humidity/accumulate
    to:
      name: concatenate1

  - from:
      name: module-temperature/map
    to:
      name: module-temperature/filter

  - from:
      name: module-temperature/filter
    to:
      name: module-temperature/accumulate

  - from:
      name: module-temperature/accumulate
    to:
      name: concatenate1

  - from:
      name: concatenate1
    to:
      name: module-collection/accumulate

  - from:
      name: module-collection/accumulate
    to:
      name: module-enrichment/map

  - from:
      name: module-enrichment/map
    to:
      name: sink

Para obter instruções de implantação passo a passo, consulte Módulos de Implantação de WebAssembly (WASM) e definições de grafo. Para experimentar um fluxo de dados que usa este exemplo, consulte Exemplo 2: Implantar um grafo complexo.

Como o grafo complexo funciona

O grafo complexo processa três fluxos de dados e os combina em análises de sensores enriquecidas:

Como mostrado no diagrama, os dados fluem de uma única origem através de múltiplas etapas de processamento:

1. Módulo de janela: Atrasa os dados recebidos para processamento baseado em tempo
2. Operação de ramificação: Roteia os dados com base no tipo de conteúdo (dados de sensor vs. instantâneos)
3. Caminho de processamento de temperatura:
   • Converte Fahrenheit em Celsius
   • Filtra leituras inválidas
   • Calcula resumos estatísticos ao longo de janelas de tempo
4. Caminho de processamento de umidade:
   • Acumula medições de umidade com análise estatística
5. Caminho de processamento de imagem:
   • Formata dados de imagem para processamento
   • Realiza detecção de objetos em snapshots da câmera
6. Agregação final:
   • Concatena todos os fluxos de dados processados
   • Agrega os resultados de múltiplos sensores
   • Adiciona metadados e alertas de superaquecimento

O grafo utiliza módulos especializados dos exemplos em Rust:

• Módulo de janela para atrasos no processamento baseado em tempo
• Módulos de temperatura para conversão, filtragem e análise estatística
• Módulo de umidade para processamento de dados ambientais
• Módulos de instantâneo para roteamento de dados de imagem e detecção de objetos
• Módulo de formatação para preparação de imagens para processamento
• Módulo de coleta para agregação de dados de múltiplos sensores
• Módulo de enriquecimento para adição de metadados e geração de alertas

As operações de ramificação permitem o processamento paralelo de diferentes entradas de sensores, possibilitando que o grafo lide com múltiplos tipos de dados de forma eficiente dentro de um único fluxo de trabalho.

Como definições de grafo se tornam fluxos de dados

Veja como as definições de grafo se relacionam com os grafos de fluxo de dados do Azure IoT Operations:

Seu arquivo YAML define a lógica de processamento interna com operações de origem/destino como pontos de extremidade abstratos. Isso se torna o artefato da definição de grafo. Os módulos referenciados implementam os operadores de processamento reais como módulos WASM. Tanto as definições de grafo quanto os módulos WASM são enviados para um registro de contêiner (como o Azure Container Registry) como artefatos OCI para armazenamento no registro.

O Azure Resource Manager ou o recurso do Kubernetes “envolve” a definição de grafo e a conecta a pontos de extremidade reais como o recurso de grafo de fluxo de dados. Durante a implantação em tempo de execução, o mecanismo de fluxo de dados busca os artefatos no registro e os implanta. Para o mapeamento de pontos de extremidade, as operações de origem/destino abstratas em seu grafo se conectam a tópicos MQTT reais, Azure Event Hubs ou outras fontes de dados.

Por exemplo, este diagrama ilustra a relação entre definições de grafo, módulos WASM e grafos de fluxo de dados:

Para saber mais sobre como configurar grafos de fluxo de dados, consulte Usar WebAssembly com grafos de fluxo de dados.

Implantação de registro

Tanto as definições de grafo quanto os módulos WASM devem ser enviados para um registro de contêiner como artefatos da Open Container Initiative (OCI) antes que os grafos de fluxo de dados possam referenciá-los:

• As definições de grafo são empacotadas como artefatos OCI com o tipo de mídia application/vnd.oci.image.config.v1+json
• Os módulos WASM são empacotados como artefatos OCI contendo o binário WebAssembly compilado
• Use versionamento semântico (como my-graph:1.0.0, temperature-converter:2.1.0) para o gerenciamento adequado de dependências
• O suporte a registro é compatível com o Azure Container Registry, Docker Hub e outros registros compatíveis com OCI

A separação permite uma lógica reutilizável em que a mesma definição de grafo é implantada com diferentes pontos de extremidade. Ele fornece independência de ambiente, onde desenvolvimento, homologação e produção utilizam diferentes fontes de dados. Ele também oferece suporte a implantação modular, onde você atualiza as configurações dos pontos de extremidade sem alterar a lógica de processamento.

Para obter instruções detalhadas sobre como carregar definições de grafo e módulos WASM em registros, consulte módulos de implantação de WASM (WebAssembly) e definições de grafo.

Parâmetros de configuração do módulo

Definições de grafos podem especificar parâmetros de tempo de execução para operadores WASM por meio de configurações de módulo:

moduleConfigurations:
  - name: my-operator/map
    parameters:
      threshold:
        name: temperature_threshold
        description: "Temperature threshold for filtering"
        required: true
      unit:
        name: output_unit
        description: "Output temperature unit"
        required: false

Esses parâmetros são passados para a função init do seu operador WASM em tempo de execução, permitindo configuração dinâmica sem a necessidade de reconstruir módulos. Para exemplos detalhados de como acessar e usar esses parâmetros em seu código Rust e Python, consulte Parâmetros de configuração do módulo.

Para um exemplo completo de implementação, consulte o módulo de ramificação, que demonstra o uso de parâmetros para lógica de roteamento condicional.

Próximas etapas

• Desenvolver módulos WebAssembly para grafos de fluxo de dados
• Usar WebAssembly com grafos de fluxo de dados
• Configurar pontos de extremidade do registro