Skapa ett dataflödesdiagram i Azure IoT Operations

Ett dataflödesdiagram är en sammansättningsbar bearbetningspipeline som transformerar data när de flyttas mellan källor och mål. Ett standarddataflöde följer en fast sekvens av berika, filtrera och kartlägga. Med ett dataflödesdiagram kan du länka transformeringar i valfri ordning, förgrena till parallella sökvägar och aggregera data över tidsfönster.

Den här artikeln går igenom hur du skapar ett dataflödesdiagram steg för steg. En översikt över dataflödesdiagram och tillgängliga transformeringar finns i Översikt över dataflödesdiagram.

Dataflödesdiagram stöder för närvarande endast MQTT-, Kafka- och OpenTelemetry-slutpunkter. De stöder inte andra endpoint-typer som Data Lake, Microsoft Fabric OneLake, Azure Data Explorer och Local Storage.

Transformer använder ett uttrycksspråk för att beräkna värden, testvillkor och referensfält. Uttryck hänvisar till indata efter position, inte namn: den första indatan i inputs listan är $1, den andra är $2, och så vidare. Inbyggda funktioner som cToF konvertera och manipulera dessa värden.

För den fullständiga listan över operatorer, funktioner, datatyper och metadatafält, se referensen Expressions.

Förutsättningar

En instans av Azure IoT Operations distribuerad i ett Kubernetes-kluster. Mer information finns i Deploy Azure IoT Operations.

Azure CLI installerat på utvecklingsdatorn. Kontrollera tillgängliga Azure CLI-tillägg för den minsta versionen som krävs för att använda azure-iot-ops-tillägget. Använd az --version för att kontrollera din version och az upgrade uppdatera om det behövs. Mer information finns i Installera Azure CLI.
Tillägget Azure IoT Operations för Azure CLI. Använd följande kommando för att lägga till tillägget eller uppdatera det till den senaste versionen:
```
az extension add --upgrade --name azure-iot-ops
```

Azure IoT Operations version 1.2 eller senare.
En dataflödesprofil. Du kan använda standardprofilen.
En dataflödesslutpunkt för din källa och ditt mål. Standardslutpunkten för MQTT-koordinatorn fungerar för att komma igång.

De Azure CLI exemplen i denna artikel använder miljövariabler så att du kan sätta varje värde en gång och sedan kopiera och klistra in kommandona as-is. Om du använder Azure IoT Operations Codespaces-miljön från quickstart är dessa variabler redan inställda för dig och du kan hoppa över detta steg. Annars, ställ in följande miljövariabler i ditt skal innan du kör kommandona.

Följande skript anger de mest använda miljövariablerna:

Miljövariabel	Beskrivning
`SUBSCRIPTION_ID`	ID:t för prenumerationen som innehåller din Azure IoT Operations-instans.
`RESOURCE_GROUP`	Namnet på resursgruppen som innehåller din Azure IoT Operations-instans.
`AIO_INSTANCE_NAME`	Namnet på din Azure IoT Operations-instans. För att lista dina instanser, kör `az iot ops list -o table`.
`CLUSTER_NAME`	Namnet på det Azure Arc-aktiverade Kubernetes-klustret som hostar din instans.
`LOCATION`	Azure-regionen att använda för nya resurser, till exempel `eastus`.

Bash
PowerShell

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>"

Du behöver bara ställa in de variabler som denna artikel använder. Den här artikeln kan använda ytterligare miljövariabler för resursnamn som du väljer. Artikeln förklarar hur man placerar dem där de introduceras.

Denna artikel använder GRAPH_NAME också och PROFILE miljövariablerna för dataflödesgrafen och profilnamnen. Ställ in varje innan du kör de relaterade kommandona.

Skapa ett dataflödesdiagram

Ett dataflödesdiagram innehåller tre typer av element: källor som tar in data, transformerar den och mål som skickar ut dem. Anslut dem i den ordning du vill att data ska flöda.

I operationserfarenheten, gå till din Azure IoT Operations-instans.
Välj Dataflödesdiagram>Skapa dataflödesdiagram.
Ange ett namn för dataflödesdiagrammet och välj en dataflödesprofil. Standardprofilen är markerad som standard.
Skapa din pipeline genom att lägga till objekt på duken.
1. Lägg till en källa: Välj källslutpunkten och konfigurera ämnena att prenumerera på för inkommande meddelanden.
2. Lägg till transformeringar: Välj en eller flera transformeringar för att bearbeta data. Tillgängliga transformationer inkluderar karta, filter, förgrening, sammanfogning, fönster och gas. Mer information om varje transformeringstyp finns i Översikt över dataflödesdiagram.
3. Lägg till ett mål: Välj målslutpunkten och konfigurera ämnet eller sökvägen för att skicka bearbetade data till.
Anslut elementen i den ordning du vill att data ska flöda.
Välj Spara för att distribuera dataflödesdiagrammet.

Azure CLI använder en dataflödesgraf från en enda JSON-konfigurationsfil som innehåller alla noder och anslutningar. Använd az iot ops dataflowgraph apply för att skapa eller ersätta diagrammet. Följande exempel läser temperaturdata, omvandlar dem till Fahrenheit och skickar dem till ett destinationsämne.

Skapa en graph.json fil med dataflödesdiagramegenskaperna. I graph.json filen lagras varje transforms regler i value fältet som en escaped JSON-sträng. Den läsbara formen för varje transformerings regler finns i instruktioner för den transformeringstypen.

{
  "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"
      }
    }
  ]
}

Använd konfigurationsfilen.

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

Grafen använder default dataflödesprofilen. Om du vill använda en annan profil lägger du till --profile <PROFILE_NAME>.

Skapa en Bicep-fil .bicep med följande struktur. Det här exemplet skapar ett dataflödesdiagram som läser temperaturdata, konverterar dem till Fahrenheit och skickar dem till ett målämne.

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

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

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

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

resource dataflowGraph 'Microsoft.IoTOperations/instances/dataflowProfiles/dataflowGraphs@2026-03-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' }
      }
    ]
  }
}

Distribuera Bicep-filen:

az deployment group create --resource-group $RESOURCE_GROUP --template-file main.bicep

Viktigt!

Användning av Kubernetes-distributionsmanifest stöds inte i produktionsmiljöer och bör endast användas för felsökning och testning.

Skapa en Kubernetes-manifestfil .yaml med följande struktur. Det här exemplet skapar ett dataflödesdiagram som läser temperaturdata, konverterar dem till Fahrenheit och skickar dem till ett målämne.

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

Använd manifestet:

kubectl apply -f main.yaml

Konfigurera källan

Källan definierar var data kommer in i pipelinen. Ange en slutpunktsreferens och ett eller flera avsnitt.

I dataflödesgrafredigeraren väljer du källelementet och konfigurerar:

Inställning	Beskrivning
Slutpunkt	Den dataflödesslutpunkt som ska användas. Välj standard för den lokala MQTT-koordinatorn.
Topics	Ett eller flera avsnitt att prenumerera på för inkommande meddelanden.

CLI tillämpar hela diagrammet samtidigt, så konfigurera källan som en Source nod i konfigurationsfilen graph.json och kör az iot ops dataflowgraph applysedan :

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

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

Viktigt!

Användning av Kubernetes-distributionsmanifest stöds inte i produktionsmiljöer och bör endast användas för felsökning och testning.

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

Lägga till transformationer

Transformeringar bearbetar data mellan källan och målet. Varje transform refererar till en inbyggd artefakt och har konfigurationsregler.

De tillgängliga inbyggda transformerna är:

Omvandla	Artifact	Beskrivning
Karta	`azureiotoperations/graph-dataflow-map:1.0.0`	Byt namn på, omstrukturera, beräkna och kopiera fält.
Filter	`azureiotoperations/graph-dataflow-filter:1.0.0`	Ta bort meddelanden som matchar ett villkor.
Gren	`azureiotoperations/graph-dataflow-branch:1.0.0`	Dirigera varje meddelande till en `true` eller `false` sökväg baserat på ett villkor.
Concatenate	`azureiotoperations/graph-dataflow-concatenate:1.0.0`	Sammanfoga två eller flera sökvägar tillbaka till en enda sökväg.
Fönster	`azureiotoperations/graph-dataflow-window:1.0.0`	Samla in meddelanden över ett tidsintervall och aggregera sedan.
Throttle	`azureiotoperations/graph-dataflow-throttle:1.0.0`	Begränsa meddelandefrekvensen per MQTT-ämnesmönster.

Mer information om hur du berikar meddelanden med externa data finns i Berika med externa data.

I dataflödesdiagramredigeraren väljer du Lägg till transformering och väljer transformeringstyp. Konfigurera reglerna i det visuella redigeringsprogrammet.

Varje transformation är en nod med nodeType satt till Graph i din konfigurationsfil graph.json. Transformens regler är ett JSON-objekt, som den här kartan som konverterar temperatur till Fahrenheit:

{
  "map": [
    {
      "inputs": ["temperature"],
      "output": "temperature_f",
      "expression": "cToF($1)"
    }
  ]
}

Egenskapen configuration tar dessa regler som en sträng, så undvik regel-JSON och placera den i value fältet. Använd den fullständiga grafen med az iot ops dataflowgraph apply:

{
  "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)\"}]}"
      }
    ]
  }
}

Tip

För att generera escape-strängen, spara reglerna till en fil, till exempel rules.json, kör jq -c . rules.json och klistra in utdata på en enda rad i fältet value.

Varje transformering är en nod med nodeType: 'Graph'. Egenskapen configuration skickar regler som en JSON-sträng:

{
  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)"}]}'
      }
    ]
  }
}

Viktigt!

Användning av Kubernetes-distributionsmanifest stöds inte i produktionsmiljöer och bör endast användas för felsökning och testning.

Varje transformering är en nod med nodeType: Graph. Egenskapen configuration skickar regler som en JSON-sträng:

- 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)"
              }
            ]
          }

Länka flera transformationer

Kedja ett valfritt antal transformationer. Anslut dem i avsnittet nodeConnections i den ordning du vill att data ska flöda:

Dra anslutningar mellan transformeringar på arbetsytan för att definiera bearbetningsordningen.

Definiera bearbetningsordningen nodeConnections i avsnittet i konfigurationsfilen graph.json :

"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' } }
]

Viktigt!

Användning av Kubernetes-distributionsmanifest stöds inte i produktionsmiljöer och bör endast användas för felsökning och testning.

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

Konfigurera målet

Destinationen avgör vart bearbetad data går. Ange en slutpunktsreferens och ett ämne eller en sökväg.

Välj målelementet och konfigurera:

Inställning	Beskrivning
Slutpunkt	Dataflödesslutpunkten som data ska skickas till.
Topic	Ämnet eller sökvägen för att publicera bearbetade data till.

Konfigurera målet som en Destination nod i konfigurationsfilen graph.json och använd sedan det fullständiga diagrammet med az iot ops dataflowgraph apply:

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

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

Viktigt!

Användning av Kubernetes-distributionsmanifest stöds inte i produktionsmiljöer och bör endast användas för felsökning och testning.

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

Dynamisk ämnesroutning baserat på meddelandeinnehåll finns i Dirigera meddelanden till olika ämnen.

Kontrollera att dataflödesdiagrammet fungerar

När du har distribuerat ett dataflödesdiagram kontrollerar du att det körs:

I operationsupplevelsen, välj din dataflödesgraf för att se dess status. Ett felfritt diagram visar tillståndet Körs .

Använd az iot ops dataflowgraph show för att visa information om ett diagram:

az iot ops dataflowgraph show \
  --name temperature-processing \
  --instance $AIO_INSTANCE_NAME \
  --resource-group $RESOURCE_GROUP

Om du vill visa en lista över alla dataflödesdiagram som är associerade med en profil använder du az iot ops dataflowgraph list:

az iot ops dataflowgraph list \
  --instance $AIO_INSTANCE_NAME \
  --resource-group $RESOURCE_GROUP

Kontrollera resursens DataflowGraph status:

az resource show --resource-group $RESOURCE_GROUP --resource-type Microsoft.IoTOperations/instances/dataflowProfiles/dataflowGraphs --name $GRAPH_NAME --parent instances/$AIO_INSTANCE_NAME/dataflowProfiles/$PROFILE

Viktigt!

Användning av Kubernetes-distributionsmanifest stöds inte i produktionsmiljöer och bör endast användas för felsökning och testning.

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

Kontrollera om det finns några fel i poddloggarna:

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

Feedback

Var den här sidan till hjälp?

Last updated on 2026-07-31

Skapa ett dataflödesdiagram i Azure IoT Operations

Förutsättningar

Skapa ett dataflödesdiagram

Konfigurera källan

Lägga till transformationer

Länka flera transformationer

Konfigurera målet

Kontrollera att dataflödesdiagrammet fungerar

Relaterat innehåll

Feedback

Ytterligare resurser