Elaborare i dati con grafici del flusso di dati

1. Nell'esperienza di Operazioni, vai alla tua istanza di Operazioni IoT di Azure.

2. Selezionare Grafico flusso di dati>Crea grafico flusso di dati.

   

3. Immettere un nome per il grafico del flusso di dati e selezionare un profilo del flusso di dati. Il profilo predefinito è selezionato per impostazione predefinita.

   

4. Costruisci la tua pipeline aggiungendo elementi alla tela.

   1. Aggiungere un'origine: selezionare l'endpoint di origine e configurare gli argomenti per sottoscrivere i messaggi in arrivo.

      

      1. Aggiungi trasformazioni: selezionare una o più trasformazioni per elaborare i dati. Le trasformazioni disponibili includono mappa, filtro, ramo, concat e finestra. Per informazioni dettagliate su ogni tipo di trasformazione, vedere Panoramica dei grafici del flusso di dati.

      

      

   2. Aggiungere una destinazione: selezionare l'endpoint di destinazione e configurare l'argomento o il percorso in cui inviare i dati elaborati.

      

5. Connettere gli elementi nell'ordine in cui si desidera che i dati vengano trasmessi.

   

6. Selezionare Salva per distribuire il grafico del flusso di dati.

Creare un file Bicep .bicep con la struttura seguente. In questo esempio viene creato un grafico del flusso di dati che legge i dati relativi alla temperatura, li converte in Fahrenheit e li invia a un argomento di destinazione.

param aioInstanceName string = '<AIO_INSTANCE_NAME>'
param customLocationName string = '<CUSTOM_LOCATION_NAME>'

resource aioInstance 'Microsoft.IoTOperations/instances@2025-10-01' existing = {
  name: aioInstanceName
}

resource customLocation 'Microsoft.ExtendedLocation/customLocations@2021-08-31-preview' existing = {
  name: customLocationName
}

resource defaultDataflowProfile 'Microsoft.IoTOperations/instances/dataflowProfiles@2025-10-01' existing = {
  parent: aioInstance
  name: 'default'
}

resource dataflowGraph 'Microsoft.IoTOperations/instances/dataflowProfiles/dataflowGraphs@2025-10-01' = {
  parent: defaultDataflowProfile
  name: 'temperature-processing'
  extendedLocation: {
    name: customLocation.id
    type: 'CustomLocation'
  }
  properties: {
    profileRef: 'default'
    mode: 'Enabled'
    nodes: [
      {
        nodeType: 'Source'
        name: 'sensors'
        sourceSettings: {
          endpointRef: 'default'
          dataSources: [
            'telemetry/temperature'
          ]
        }
      }
      {
        nodeType: 'Graph'
        name: 'convert'
        graphSettings: {
          registryEndpointRef: 'default'
          artifact: 'azureiotoperations/graph-dataflow-map:1.0.0'
          configuration: [
            {
              key: 'rules'
              value: '{"map":[{"inputs":["*"],"output":"*"},{"inputs":["temperature"],"output":"temperature_f","expression":"cToF($1)"}]}'
            }
          ]
        }
      }
      {
        nodeType: 'Destination'
        name: 'output'
        destinationSettings: {
          endpointRef: 'default'
          dataDestination: 'telemetry/converted'
        }
      }
    ]
    nodeConnections: [
      {
        from: { name: 'sensors' }
        to: { name: 'convert' }
      }
      {
        from: { name: 'convert' }
        to: { name: 'output' }
      }
    ]
  }
}

Distribuire il file Bicep:

az deployment group create --resource-group <RESOURCE_GROUP> --template-file <FILE>.bicep

Creare un file manifesto .yaml Kubernetes con la struttura seguente. In questo esempio viene creato un grafico del flusso di dati che legge i dati relativi alla temperatura, li converte in Fahrenheit e li invia a un argomento di destinazione.

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

    - nodeType: Graph
      name: convert
      graphSettings:
        registryEndpointRef: default
        artifact: azureiotoperations/graph-dataflow-map:1.0.0
        configuration:
          - key: rules
            value: |
              {
                "map": [
                  {
                    "inputs": ["*"],
                    "output": "*"
                  },
                  {
                    "inputs": ["temperature"],
                    "output": "temperature_f",
                    "expression": "cToF($1)"
                  }
                ]
              }

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

  nodeConnections:
    - from:
        name: sensors
      to:
        name: convert
    - from:
        name: convert
      to:
        name: output

Applicare il manifesto:

kubectl apply -f <FILE>.yaml

Nell'editor del grafico del flusso di dati selezionare l'elemento di origine e configurare:

{
  nodeType: 'Source'
  name: 'sensors'
  sourceSettings: {
    endpointRef: 'default'
    dataSources: [
      'telemetry/temperature'
      'telemetry/humidity'
    ]
  }
}

- nodeType: Source
  name: sensors
  sourceSettings:
    endpointRef: default
    dataSources:
      - telemetry/temperature
      - telemetry/humidity

Nell'editor del grafico del flusso di dati selezionare Aggiungi trasformazione e scegliere il tipo di trasformazione. Configurare le regole nell'editor visivo.

Ogni trasformazione è un nodo con nodeType: 'Graph'. La configuration proprietà passa le regole come stringa JSON:

{
  nodeType: 'Graph'
  name: 'convert'
  graphSettings: {
    registryEndpointRef: 'default'
    artifact: 'azureiotoperations/graph-dataflow-map:1.0.0'
    configuration: [
      {
        key: 'rules'
        value: '{"map":[{"inputs":["temperature"],"output":"temperature_f","expression":"cToF($1)"}]}'
      }
    ]
  }
}

Ogni trasformazione è un nodo con nodeType: Graph. La configuration proprietà passa le regole come stringa JSON:

- nodeType: Graph
  name: convert
  graphSettings:
    registryEndpointRef: default
    artifact: azureiotoperations/graph-dataflow-map:1.0.0
    configuration:
      - key: rules
        value: |
          {
            "map": [
              {
                "inputs": ["temperature"],
                "output": "temperature_f",
                "expression": "cToF($1)"
              }
            ]
          }

Trascinare le connessioni tra trasformazioni nell'area di disegno per definire l'ordine di elaborazione.

nodeConnections: [
  { from: { name: 'sensors' }, to: { name: 'remove-bad-data' } }
  { from: { name: 'remove-bad-data' }, to: { name: 'convert' } }
  { from: { name: 'convert' }, to: { name: 'output' } }
]

nodeConnections:
  - from: { name: sensors }
    to: { name: remove-bad-data }
  - from: { name: remove-bad-data }
    to: { name: convert }
  - from: { name: convert }
    to: { name: output }

Selezionare l'elemento di destinazione e configurare:

{
  nodeType: 'Destination'
  name: 'output'
  destinationSettings: {
    endpointRef: 'default'
    dataDestination: 'telemetry/processed'
  }
}

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

Nell'esperienza Operazioni selezionare il grafico del flusso di dati per visualizzarne lo stato. Un grafico integro mostra uno stato In esecuzione .

Controllare lo stato della DataflowGraph risorsa:

az resource show --resource-group <RESOURCE_GROUP> --resource-type Microsoft.IoTOperations/instances/dataflowProfiles/dataflowGraphs --name <GRAPH_NAME> --parent instances/<INSTANCE_NAME>/dataflowProfiles/<PROFILE_NAME>

kubectl get dataflowgraph temperature-processing -n azure-iot-operations

Controllare i log dei pod per eventuali errori:

kubectl logs -l app=dataflow -n azure-iot-operations --tail=50