Créer un graphique de flux de données dans Opérations Azure IoT

Un graphique de flux de données est un pipeline de traitement composable qui transforme les données à mesure qu’elles se déplacent entre les sources et les destinations. Un flux de données standard suit une séquence d’enrichissement, de filtre, de mappage fixe. Un graphique de flux de données vous permet de chaîner des transformations dans n’importe quel ordre, de brancher en chemins parallèles et d’agréger des données au fil des fenêtres de temps.

Cet article décrit la création d’un graphique de flux de données étape par étape. Pour obtenir une vue d’ensemble des graphiques de flux de données et des transformations disponibles, consultez vue d’ensemble des graphiques de flux de données.

Les graphiques de flux de données prennent actuellement en charge uniquement les points de terminaison MQTT, Kafka et OpenTelemetry. Ils ne prennent pas en charge d'autres types de terminaux tels que lac de données, Microsoft Fabric OneLake, Azure Data Explorer et Local Storage.

Les transformations utilisent un langage d’expressions pour calculer les valeurs, les conditions de test et les champs de référence. Les expressions désignent les entrées par position, et non par le nom : la première entrée de la inputs liste est $1, la seconde est $2, et ainsi de suite. Des fonctions intégrées telles que cToF convertissent et manipulent ces valeurs.

Pour la liste complète des opérateurs, fonctions, types de données et champs de métadonnées, voir la référence Expressions.

Prerequisites

Instance de Opérations Azure IoT déployée dans un cluster Kubernetes. Pour plus d’informations, consultez Deploy Opérations Azure IoT.

La Azure CLI installée sur votre ordinateur de développement. Vérifiez les extensions Azure CLI disponibles pour connaître la version minimale requise afin d’utiliser l’extension azure-iot-ops. Utilisez az --version pour vérifier votre version et az upgrade pour effectuer une mise à jour si nécessaire. Pour plus d’informations, consultez la rubrique Installation de l’interface de ligne de commande Azure (CLI).
Extension Opérations Azure IoT pour le Azure CLI. Utilisez la commande suivante pour ajouter l’extension ou la mettre à jour vers la dernière version :
```
az extension add --upgrade --name azure-iot-ops
```

Opérations Azure IoT version 1.2 ou ultérieure.
Profil de flux de données. Vous pouvez utiliser le profil par défaut.
Point de terminaison de flux de données pour votre source et votre destination. Le point de terminaison broker MQTT par défaut fonctionne pour le démarrage.

Les exemples Azure CLI de cet article utilisent des variables d’environnement afin de pouvoir définir chaque valeur une fois puis copier-coller les commandes as-is. Si vous utilisez l'environnement Opérations Azure IoT Codespaces du quickstart, ces variables sont déjà définies pour vous et vous pouvez sauter cette étape. Sinon, définissez les variables d’environnement suivantes dans votre shell avant d’exécuter les commandes.

Les scripts suivants définissent les variables d’environnement les plus couramment utilisées :

Variable d'environnement	Description
`SUBSCRIPTION_ID`	L’identifiant de l’abonnement contenant votre instance Opérations Azure IoT.
`RESOURCE_GROUP`	Le nom du groupe de ressources contenant votre instance Opérations Azure IoT.
`AIO_INSTANCE_NAME`	Le nom de votre instance Opérations Azure IoT. Pour lister vos instances, exécutez `az iot ops list -o table`.
`CLUSTER_NAME`	Le nom du cluster Kubernetes compatible Azure Arc qui héberge votre instance.
`LOCATION`	La région Azure à utiliser pour de nouvelles ressources, par exemple `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>"

Vous n’avez qu’à définir les variables utilisées dans cet article. Cet article peut utiliser des variables d’environnement supplémentaires pour les noms de ressources que vous choisissez. L’article explique comment les placer là où ils sont introduits.

Cet article utilise également les variables d’environnement GRAPH_NAME et PROFILE pour le graphe de flux de données et les noms de profil. Définissez chacune avant d’exécuter les commandes associées.

Créer un graphe de flux de données

Un graphique de flux de données contient trois types d’éléments : les sources qui apportent des données, les transforment et les destinations qui l’envoient. Connectez-les dans l’ordre dans lequel vous souhaitez que les données soient transmises.

Dans l’expérience opérations, allez sur votre instance Opérations Azure IoT.
SélectionnezGraphique de flux de données Créer un graphique> de flux de données.
Entrez un nom pour le graphique de flux de données et sélectionnez un profil de flux de données. Le profil par défaut est sélectionné par défaut.
Générez votre pipeline en ajoutant des éléments au canevas :
1. Ajoutez une source : sélectionnez le point de terminaison source et configurez les rubriques pour s’abonner aux messages entrants.
2. Ajouter des transformations : sélectionnez une ou plusieurs transformations pour traiter les données. Les transformations disponibles incluent la mise en correspondance, le filtrage, le branchement, la concaténation, le fenêtrage et la limitation de débit. Pour plus d’informations sur chaque type de transformation, consultez vue d’ensemble des graphiques de flux de données.
3. Ajoutez une destination : sélectionnez le point de terminaison de destination et configurez la rubrique ou le chemin d’accès pour envoyer des données traitées.
Connectez les éléments dans l’ordre dans lequel vous souhaitez que les données soient transmises.
Sélectionnez Enregistrer pour déployer le graphique de flux de données.

L’Azure CLI utilise un graphe de flux de données à partir d’un seul fichier de configuration JSON qui contient tous les nœuds et connexions. Utilisez az iot ops dataflowgraph apply pour créer ou remplacer le graphe. L’exemple suivant lit les données de température, les convertit en Fahrenheit, puis les envoie à un sujet de destination.

Créez un graph.json fichier avec les propriétés du graphique de flux de données. Dans le graph.json fichier, stockez les règles de chaque transformation dans le value champ sous forme de chaîne JSON échappée. Pour obtenir la forme lisible des règles de chaque transformation, consultez la procédure de ce type de transformation.

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

Appliquez le fichier de configuration.

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

Le graphique utilise le default profil de flux de données. Pour utiliser un autre profil, ajoutez --profile <PROFILE_NAME>.

Créez un fichier Bicep .bicep avec la structure suivante. Cet exemple crée un graphique de flux de données qui lit les données de température, les convertit en Fahrenheit et les envoie à une rubrique de destination.

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

Déployez le fichier Bicep :

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

Important

L’utilisation des manifestes de déploiement Kubernetes n’est pas prise en charge dans les environnements de production et ne doit être utilisée que pour le débogage et le test.

Créez un fichier manifeste .yaml Kubernetes avec la structure suivante. Cet exemple crée un graphique de flux de données qui lit les données de température, les convertit en Fahrenheit et les envoie à une rubrique de destination.

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

Appliquez le manifeste :

kubectl apply -f main.yaml

Configurer la source

La source définit l’emplacement où les données entrent dans le pipeline. Spécifiez une référence de point de terminaison et une ou plusieurs rubriques.

Dans l’éditeur de graphique de flux de données, sélectionnez l’élément source et configurez :

Réglage	Description
Point de terminaison	Point de terminaison de flux de données à utiliser. Sélectionnez la valeur par défaut pour le répartiteur MQTT local.
Rubriques	Une ou plusieurs rubriques à abonner pour les messages entrants.

L’interface CLI applique le graphique entier à la fois. Configurez donc la source en tant que Source nœud dans votre graph.json fichier de configuration, puis exécutez az iot ops dataflowgraph apply:

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

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

Important

L’utilisation des manifestes de déploiement Kubernetes n’est pas prise en charge dans les environnements de production et ne doit être utilisée que pour le débogage et le test.

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

Ajouter des transformations

Transforme les données de traitement entre la source et la destination. Chaque transformation fait référence à un artefact intégré et possède des règles de configuration.

Les transformations intégrées disponibles sont les suivantes :

Transformer	Artéfact	Description
Carte	`azureiotoperations/graph-dataflow-map:1.0.0`	Renommez, restructurez, calculez et copiez des champs.
Filtre	`azureiotoperations/graph-dataflow-filter:1.0.0`	Supprimez les messages qui correspondent à une condition.
Branche	`azureiotoperations/graph-dataflow-branch:1.0.0`	Acheminer chaque message vers un chemin `true` ou `false` en fonction d’une condition.
Concatenate	`azureiotoperations/graph-dataflow-concatenate:1.0.0`	Fusionnez deux chemins d’accès ou plus en un.
Window	`azureiotoperations/graph-dataflow-window:1.0.0`	Collecter des messages sur un intervalle de temps, puis agréger.
limitation du débit	`azureiotoperations/graph-dataflow-throttle:1.0.0`	Limitez le taux de messages par schéma de sujet MQTT.

Pour plus d’informations sur l’enrichissement des messages avec des données externes, consultez Enrichir avec des données externes.

Dans l’éditeur de graphique de flux de données, sélectionnez Ajouter une transformation et choisissez le type de transformation. Configurez les règles dans l’éditeur visuel.

Chaque transformation est un nœud, avec nodeType défini sur Graph dans votre fichier de configuration graph.json. Les règles de la transformation sont un objet JSON, comme cette carte qui convertit la température en Fahrenheit :

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

La configuration propriété prend ces règles comme une chaîne, donc échappez au JSON des règles et placez-la dans le value champ. Appliquez le graphique complet avec 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

Pour générer la chaîne échappée, sauvegardez les règles dans un fichier comme rules.json, exécutez jq -c . rules.json, puis collez la sortie ligne unique dans le value champ.

Chaque transformation est un nœud avec nodeType: 'Graph'. La configuration propriété transmet des règles en tant que chaîne 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)"}]}'
      }
    ]
  }
}

Important

L’utilisation des manifestes de déploiement Kubernetes n’est pas prise en charge dans les environnements de production et ne doit être utilisée que pour le débogage et le test.

Chaque transformation est un nœud avec nodeType: Graph. La configuration propriété transmet des règles en tant que chaîne 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)"
              }
            ]
          }

Chaîner plusieurs transformations

Enchaîne n’importe quel nombre de transformations. Connectez-les dans la nodeConnections section dans l’ordre dans lequel vous souhaitez que les données soient transmises :

Faites glisser les connexions entre les transformations sur le canevas pour définir l’ordre de traitement.

Définissez l’ordre de traitement dans la nodeConnections section de votre graph.json fichier config :

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

Important

L’utilisation des manifestes de déploiement Kubernetes n’est pas prise en charge dans les environnements de production et ne doit être utilisée que pour le débogage et le test.

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

Configurer la destination

La destination définit où vont les données traitées. Spécifiez une référence de point de terminaison et une rubrique ou un chemin d’accès.

Sélectionnez l’élément de destination et configurez :

Réglage	Description
Point de terminaison	Point de terminaison de flux de données vers laquelle envoyer des données.
Topic	Rubrique ou chemin d’accès vers lequel publier des données traitées.

Configurez la destination en tant que Destination nœud dans votre graph.json fichier de configuration, puis appliquez le graphique complet avec 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'
  }
}

Important

L’utilisation des manifestes de déploiement Kubernetes n’est pas prise en charge dans les environnements de production et ne doit être utilisée que pour le débogage et le test.

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

Pour le routage dynamique des rubriques en fonction du contenu des messages, consultez Acheminer les messages vers différentes rubriques.

Vérifier que le graphique de flux de données fonctionne

Après avoir déployé un graphique de flux de données, vérifiez qu’il est en cours d’exécution :

Dans l’expérience d’opérations, sélectionnez votre graphique de flux de données pour en voir l’état. Un graphique sain montre un état opérationnel.

Permet az iot ops dataflowgraph show d’afficher les détails d’un graphique :

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

Pour répertorier tous les graphiques de flux de données associés à un profil, utilisez az iot ops dataflowgraph list:

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

Vérifiez l’état de la DataflowGraph ressource :

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

Important

L’utilisation des manifestes de déploiement Kubernetes n’est pas prise en charge dans les environnements de production et ne doit être utilisée que pour le débogage et le test.

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

Vérifiez les journaux du pod pour toute erreur :

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

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-07-31

Créer un graphique de flux de données dans Opérations Azure IoT

Prerequisites

Créer un graphe de flux de données

Configurer la source

Ajouter des transformations

Chaîner plusieurs transformations

Configurer la destination

Vérifier que le graphique de flux de données fonctionne

Contenu connexe

Commentaires

Ressources supplémentaires