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

As definições de grafos são centrais no desenvolvimento do WASM porque definem como os seus módulos se ligam a fluxos de dados e conectores. Compreender a relação entre definições de grafos e grafos de fluxo de dados ou conectores ajuda-o a desenvolver-se eficazmente.

Este artigo se concentra na criação e configuração das definições de gráfico YAML. Para informações sobre a implementação e teste de grafos de fluxo de dados, consulte os módulos Deploy WebAssembly (WASM) e as definições de grafos.

Estrutura da definição do gráfico

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

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

Estrutura básica do gráfico

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 de 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 gráfico simples

A definição de gráfico simples demonstra um pipeline básico de três estágios 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 instruções de implementação passo a passo, veja módulos e definições de grafos Deploy WebAssembly (WASM). Para experimentar um fluxo de dados que utilize este exemplo, veja Exemplo 1: Implementação básica com um módulo WASM.

Como funciona o gráfico simples

Este gráfico 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 do mapa: Processa dados com o módulo WASM de temperatura (temperature:1.0.0)
3. Operação de coletor: envia dados convertidos para o ponto de extremidade de destino do fluxo de dados

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

Formato de entrada:

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

Formato de saída:

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

Exemplo 2: Definição de gráfico complexo

A definição complexa do gráfico demonstra um sofisticado fluxo de trabalho de processamento de vários sensores que lida com dados de temperatura, umidade e imagem 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 instruções de implementação passo a passo, veja módulos e definições de grafos Deploy WebAssembly (WASM). Para experimentar um fluxo de dados que utilize este exemplo, veja o Exemplo 2: Implementar um grafo complexo.

Como funciona o gráfico complexo

O gráfico 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 fonte através de vários estágios de processamento:

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

O gráfico usa módulos especializados dos exemplos de Rust:

• Módulo de janela para atrasos de processamento baseados no tempo
• Módulos de temperatura para conversão, filtragem e análise estatística
• Módulo de humidade para processamento de dados ambientais
• Módulos de snapshot para roteamento de dados de imagem e deteção de objetos
• Módulo de formato para preparação de imagens para processamento
• Módulo de recolha para agregação de dados multi-sensor
• 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, permitindo que o gráfico lide com vários tipos de dados de forma eficiente em um único fluxo de trabalho.

Como as definições de gráficos se tornam fluxos de dados

Veja como as definições de gráfico e os gráficos de fluxo de dados do Azure IoT Operations se relacionam:

Seu arquivo YAML define a lógica de processamento interno com operações de origem/coletor como pontos de extremidade abstratos. Isso se torna o artefato de definição de gráfico. Os módulos referenciados implementam os operadores de processamento reais como módulos WASM. As definições de gráfico e os módulos WASM são carregados em um registro de contêiner (como o Registro de Contêiner do Azure) como artefatos OCI para armazenamento do Registro.

O recurso do Azure Resource Manager ou Kubernetes "encapsula" a definição de gráfico e a conecta a pontos de extremidade reais como o recurso de gráfico de fluxo de dados. Durante a implantação em tempo de execução, o mecanismo de fluxo de dados extrai os artefatos do Registro e os implanta. Para mapeamento de ponto de extremidade, as operações abstratas de origem/coletor em seu gráfico se conectam a tópicos MQTT reais, Hubs de Eventos do Azure ou outras fontes de dados.

Por exemplo, este diagrama ilustra a relação entre definições de gráficos, módulos WASM e gráficos 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 do Registro

As definições de gráfico e os módulos WASM devem ser carregados em um registro de contêiner como artefatos da Open Container Initiative (OCI) antes que os gráficos de fluxo de dados possam fazer referência a eles:

• As definições de gráfico são empacotadas como artefatos OCI com 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 o controle de versão semântico (como my-graph:1.0.0, temperature-converter:2.1.0) para o gerenciamento adequado de dependências
• O suporte ao Registro é compatível com o Registro de Contêiner do Azure, o Hub do Docker e outros registros compatíveis com OCI

A separação permite uma lógica reutilizável onde a mesma definição de gráfico é implantada com pontos de extremidade diferentes. Ele fornece independência de ambiente onde o desenvolvimento, a preparação e a produção usam diferentes fontes de dados. Ele também suporta implantação modular onde você atualiza as configurações de ponto de extremidade sem alterar a lógica de processamento.

Para instruções detalhadas sobre o carregamento de definições de grafos e módulos WASM para registos, consulte módulos Deploy WebAssembly (WASM) e definições de grafos.

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

As definições de gráfico podem especificar parâmetros de tempo de execução para operadores WASM através 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 do init operador WASM em tempo de execução, permitindo a configuração dinâmica sem reconstruir módulos. Para obter 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 obter um exemplo completo de implementação, consulte o módulo branch, que demonstra o uso de parâmetros para lógica de roteamento condicional.

Próximos passos

• Desenvolver módulos WebAssembly para gráficos de fluxo de dados
• Usar WebAssembly com gráficos de fluxo de dados
• Configurar pontos de extremidade do Registro