Arricchire i dati con set di dati esterni nei grafici del flusso di dati

SUBSCRIPTION_ID=<subscription-id>
RESOURCE_GROUP=<resource-group-name>
AIO_INSTANCE_NAME=<instance-name>
CLUSTER_NAME=<cluster-name>
LOCATION=<region>

$SUBSCRIPTION_ID = "<subscription-id>"
$RESOURCE_GROUP = "<resource-group-name>"
$AIO_INSTANCE_NAME = "<instance-name>"
$CLUSTER_NAME = "<cluster-name>"
$LOCATION = "<region>"

Nella configurazione della trasformazione aggiungere un set di dati. Configurare:

La CLI applica l'intero grafo a partire da un file di configurazione. Aggiungi queste regole ai nodi configuration di trasformazione in U graph.json e applicale usando az iot ops dataflowgraph apply.

Le regole sono un oggetto JSON:

{
  "datasets": [
    {
      "key": "device-metadata as device",
      "inputs": ["$source.deviceId", "$context.deviceId"],
      "expression": "$1 == $2"
    }
  ],
  "map": [
    {
      "inputs": ["$context(device).displayName"],
      "output": "deviceName"
    }
  ]
}

Queste regole vengono inserite nel value campo come stringa di escape:

"configuration": [
  {
    "key": "rules",
    "value": "{\"datasets\":[{\"key\":\"device-metadata as device\",\"inputs\":[\"$source.deviceId\",\"$context.deviceId\"],\"expression\":\"$1 == $2\"}],\"map\":[{\"inputs\":[\"$context(device).displayName\"],\"output\":\"deviceName\"}]}"
  }
]

La configurazione del set di dati fa parte delle regole JSON:

configuration: [
  {
    key: 'rules'
    value: '{"datasets":[{"key":"device-metadata as device","inputs":["$source.deviceId","$context.deviceId"],"expression":"$1 == $2"}],"map":[{"inputs":["$context(device).displayName"],"output":"deviceName"}]}'
  }
]

{
  "datasets": [
    {
      "key": "device-metadata as device",
      "inputs": ["$source.deviceId", "$context.deviceId"],
      "expression": "$1 == $2"
    }
  ],
  "map": [
    {
      "inputs": ["$context(device).displayName"],
      "output": "deviceName"
    }
  ]
}

Nella configurazione di trasformazione, aggiungi un dataset e configura:

Aggiungere dynamicValues accanto a key nella voce del dataset:

{
  "datasets": [
    {
      "key": "calibration:$1 as calibration",
      "dynamicValues": ["sensorId"],
      "inputs": ["$source.sensorId", "$context.sensorId"],
      "expression": "$1 == $2"
    }
  ],
  "map": [
    {
      "inputs": ["$context(calibration).offset"],
      "output": "calibrationOffset"
    }
  ]
}

Aggiungi questa proprietà a configuration del nodo transform nel tuo graph.json come stringa con escape nel campo value. Poi applicalo usando az iot ops dataflowgraph apply.

"configuration": [
  {
    "key": "rules",
    "value": "{\"datasets\":[{\"key\":\"calibration:$1 as calibration\",\"dynamicValues\":[\"sensorId\"],\"inputs\":[\"$source.sensorId\",\"$context.sensorId\"],\"expression\":\"$1 == $2\"}],\"map\":[{\"inputs\":[\"$context(calibration).offset\"],\"output\":\"calibrationOffset\"}]}"
  }
]

configuration: [
  {
    key: 'rules'
    value: '{"datasets":[{"key":"calibration:$1 as calibration","dynamicValues":["sensorId"],"inputs":["$source.sensorId","$context.sensorId"],"expression":"$1 == $2"}],"map":[{"inputs":["$context(calibration).offset"],"output":"calibrationOffset"}]}'
  }
]

datasets:
  - key: "calibration:$1 as calibration"
    dynamicValues:
      - sensorId
    inputs:
      - $source.sensorId
      - $context.sensorId
    expression: "$1 == $2"

map:
  - inputs:
      - "$context(calibration).offset"
    output: calibrationOffset

Aggiungere regole mappa che fanno riferimento a campi arricchiti:

I riferimenti ai campi arricchiti fanno parte delle regole della mappa nel graph.json file di configurazione. Aggiungi le regole al nodo di trasformazione configuration e applica il grafo con az iot ops dataflowgraph apply:

"map": [
  {
    "inputs": [
      "$context(position).WorkingHours"
    ],
    "output": "WorkingHours"
  },
  {
    "inputs": [
      "rawValue",
      "$context(product).multiplier"
    ],
    "output": "adjustedValue",
    "expression": "$1 * $2"
  }
]

I riferimenti ai campi arricchiti fanno parte del codice JSON delle regole della mappa:

'{"datasets":[...],"map":[{"inputs":["$context(position).WorkingHours"],"output":"WorkingHours"},{"inputs":["rawValue","$context(product).multiplier"],"output":"adjustedValue","expression":"$1 * $2"}]}'

- inputs:
    - "$context(position).WorkingHours"
  output: WorkingHours

- inputs:
    - rawValue                          # $1
    - "$context(product).multiplier"    # $2
  output: adjustedValue
  expression: "$1 * $2"

Aggiungere una regola di filtro con input rawValue, $context(limits).multipliere $context(limits).baseLimite l'espressione $1 * $2 > $3.

La CLI applica l'intero grafo a partire da un file di configurazione. La seguente regola di filtro fa riferimento ai campi arricchiti $context(limits) nella sua espressione di corrispondenza, fornita come oggetto JSON:

{
  "datasets": [
    {
      "key": "device_limits as limits",
      "inputs": [
        "$source.deviceId",
        "$context.deviceId"
      ],
      "expression": "$1 == $2"
    }
  ],
  "filter": [
    {
      "inputs": [
        "rawValue",
        "$context(limits).multiplier",
        "$context(limits).baseLimit"
      ],
      "expression": "$1 * $2 > $3"
    }
  ]
}

Aggiungi queste regole al configuration del nodo di trasformazione nel tuo graph.json come stringa con caratteri di escape nel campo value, quindi applicale con az iot ops dataflowgraph apply:

"configuration": [
  {
    "key": "rules",
    "value": "{\"datasets\":[{\"key\":\"device_limits as limits\",\"inputs\":[\"$source.deviceId\",\"$context.deviceId\"],\"expression\":\"$1 == $2\"}],\"filter\":[{\"inputs\":[\"rawValue\",\"$context(limits).multiplier\",\"$context(limits).baseLimit\"],\"expression\":\"$1 * $2 > $3\"}]}"
  }
]

La seguente regola di filtro fa riferimento ai campi arricchiti $context(limits) nelle regole JSON:

'{"datasets":[{"key":"device_limits as limits","inputs":["$source.deviceId","$context.deviceId"],"expression":"$1 == $2"}],"filter":[{"inputs":["rawValue","$context(limits).multiplier","$context(limits).baseLimit"],"expression":"$1 * $2 > $3"}]}'

{
  "datasets": [
    {
      "key": "device_limits as limits",
      "inputs": ["$source.deviceId", "$context.deviceId"],
      "expression": "$1 == $2"
    }
  ],
  "filter": [
    {
      "inputs": ["rawValue", "$context(limits).multiplier", "$context(limits).baseLimit"],
      "expression": "$1 * $2 > $3"
    }
  ]
}

Configurare una regola di ramo con input quantity, $context(mult).factore $context(mult).thresholde l'espressione $1 * $2 > $3.

La CLI applica l'intero grafo a partire da un file di configurazione. Le seguenti regole di ramo instradano i messaggi utilizzando i campi arricchiti $context(mult) , forniti come oggetto JSON:

{
  "datasets": [
    {
      "key": "multipliers as mult",
      "inputs": [
        "$source.productCode",
        "$context.productCode"
      ],
      "expression": "$1 == $2"
    }
  ],
  "branch": {
    "inputs": [
      "quantity",
      "$context(mult).factor",
      "$context(mult).threshold"
    ],
    "expression": "$1 * $2 > $3"
  }
}

Aggiungi queste regole al configuration del nodo di trasformazione nel tuo graph.json come stringa con caratteri di escape nel campo value, quindi applicale con az iot ops dataflowgraph apply:

"configuration": [
  {
    "key": "rules",
    "value": "{\"datasets\":[{\"key\":\"multipliers as mult\",\"inputs\":[\"$source.productCode\",\"$context.productCode\"],\"expression\":\"$1 == $2\"}],\"branch\":{\"inputs\":[\"quantity\",\"$context(mult).factor\",\"$context(mult).threshold\"],\"expression\":\"$1 * $2 > $3\"}}"
  }
]

La seguente regola di ramo fa riferimento ai campi arricchiti $context(mult) nelle regole JSON:

'{"datasets":[{"key":"multipliers as mult","inputs":["$source.productCode","$context.productCode"],"expression":"$1 == $2"}],"branch":{"inputs":["quantity","$context(mult).factor","$context(mult).threshold"],"expression":"$1 * $2 > $3"}}'

{
  "datasets": [
    {
      "key": "multipliers as mult",
      "inputs": ["$source.productCode", "$context.productCode"],
      "expression": "$1 == $2"
    }
  ],
  "branch": {
    "inputs": ["quantity", "$context(mult).factor", "$context(mult).threshold"],
    "expression": "$1 * $2 > $3"
  }
}

Aggiungere una regola della mappa con input $context(device).* e output *.

La CLI applica l'intero grafo da un unico file di configurazione, quindi aggiungi questa regola nel punto corrispondente in U graph.json e applicala con az iot ops dataflowgraph apply:

{
  "inputs": [
    "$context(device).*"
  ],
  "output": "*"
}

{
  inputs: [ '$context(device).*' ]
  output: '*'
}

- inputs:
    - "$context(device).*"
  output: "*"

Nell'esperienza Operazioni creare un grafico del flusso di dati con arricchimento:

1. Aggiungere un'origine che esegue la lettura dall'argomento MQTT.
2. Aggiungere una trasformazione mappa . Nella configurazione del set di dati aggiungere un set di dati con la chiave dell'archivio stati e la condizione di corrispondenza.
3. Nelle regole della mappa, si fanno riferimento ai campi arricchiti usando $context(<alias>).<field> la sintassi.
4. Aggiungere una destinazione che invia all'argomento di output.

L'interfaccia della riga di comando di Azure utilizza un grafo di flusso dati da un singolo file di configurazione JSON. Creare un graph.json file con le proprietà del grafo. Nel graph.json file, ogni trasformazione memorizza le proprie regole nel value campo come stringa JSON sfuggita. Per la forma leggibile delle regole di ciascuna trasformazione, vedi l'articolo pratico per quel tipo di trasformazione.

{
  "mode": "Enabled",
  "nodes": [
    {
      "nodeType": "Source",
      "name": "sensors",
      "sourceSettings": {
        "endpointRef": "default",
        "dataSources": [
          "telemetry/sensors"
        ]
      }
    },
    {
      "nodeType": "Graph",
      "name": "enrich-and-map",
      "graphSettings": {
        "registryEndpointRef": "default",
        "artifact": "azureiotoperations/graph-dataflow-map:1.1.0",
        "configuration": [
          {
            "key": "rules",
            "value": "{\"datasets\":[{\"key\":\"device-metadata as device\",\"inputs\":[\"$source.deviceId\",\"$context.deviceId\"],\"expression\":\"$1 == $2\"}],\"map\":[{\"inputs\":[\"*\"],\"output\":\"*\"},{\"inputs\":[\"$context(device).displayName\"],\"output\":\"deviceName\"},{\"inputs\":[\"$context(device).location\"],\"output\":\"location\"}]}"
          }
        ]
      }
    },
    {
      "nodeType": "Destination",
      "name": "output",
      "destinationSettings": {
        "endpointRef": "default",
        "dataDestination": "telemetry/enriched"
      }
    }
  ],
  "nodeConnections": [
    {
      "from": {
        "name": "sensors"
      },
      "to": {
        "name": "enrich-and-map"
      }
    },
    {
      "from": {
        "name": "enrich-and-map"
      },
      "to": {
        "name": "output"
      }
    }
  ]
}

Applicare il file di configurazione.

az iot ops dataflowgraph apply \
  --name enrich-example \
  --instance $AIO_INSTANCE_NAME \
  --resource-group $RESOURCE_GROUP \
  --config-file graph.json

resource dataflowGraph 'Microsoft.IoTOperations/instances/dataflowProfiles/dataflowGraphs@2026-03-01' = {
  name: 'enrich-example'
  parent: dataflowProfile
  properties: {
    mode: 'Enabled'
    nodes: [
      {
        nodeType: 'Source'
        name: 'sensors'
        sourceSettings: {
          endpointRef: 'default'
          dataSources: [ 'telemetry/sensors' ]
        }
      }
      {
        nodeType: 'Graph'
        name: 'enrich-and-map'
        graphSettings: {
          registryEndpointRef: 'default'
          artifact: 'azureiotoperations/graph-dataflow-map:1.1.0'
          configuration: [
            {
              key: 'rules'
              value: '{"datasets":[{"key":"device-metadata as device","inputs":["$source.deviceId","$context.deviceId"],"expression":"$1 == $2"}],"map":[{"inputs":["*"],"output":"*"},{"inputs":["$context(device).displayName"],"output":"deviceName"},{"inputs":["$context(device).location"],"output":"location"}]}'
            }
          ]
        }
      }
      {
        nodeType: 'Destination'
        name: 'output'
        destinationSettings: {
          endpointRef: 'default'
          dataDestination: 'telemetry/enriched'
        }
      }
    ]
    nodeConnections: [
      { from: { name: 'sensors' }, to: { name: 'enrich-and-map' } }
      { from: { name: 'enrich-and-map' }, to: { name: 'output' } }
    ]
  }
}

apiVersion: connectivity.iotoperations.azure.com/v1
kind: DataflowGraph
metadata:
  name: enrich-example
  namespace: azure-iot-operations
spec:
  profileRef: default
  nodes:
    - nodeType: Source
      name: sensors
      sourceSettings:
        endpointRef: default
        dataSources:
          - telemetry/sensors

    - nodeType: Graph
      name: enrich-and-map
      graphSettings:
        registryEndpointRef: default
        artifact: azureiotoperations/graph-dataflow-map:1.1.0
        configuration:
          - key: rules
            value: |
              {
                "datasets": [
                  {
                    "key": "device-metadata as device",
                    "inputs": ["$source.deviceId", "$context.deviceId"],
                    "expression": "$1 == $2"
                  }
                ],
                "map": [
                  { "inputs": ["*"], "output": "*" },
                  { "inputs": ["$context(device).displayName"], "output": "deviceName" },
                  { "inputs": ["$context(device).location"], "output": "location" }
                ]
              }

    - nodeType: Destination
      name: output
      destinationSettings:
        endpointRef: default
        dataDestination: telemetry/enriched

  nodeConnections:
    - from: { name: sensors }
      to: { name: enrich-and-map }
    - from: { name: enrich-and-map }
      to: { name: output }