Déclencheur Azure Event Grid pour Azure Functions

Article
09/23/2023

Utilisez le déclencheur de fonction pour répondre à un événement envoyé par une source Event Grid. Vous devez disposer d’un abonnement aux événements auprès de la source pour recevoir des événements. Pour savoir comment créer un abonnement aux événements, consultez Création d’un abonnement. Pour plus d’informations sur la configuration des liaisons, consultez la vue d’ensemble.

Notes

Les déclencheurs Event Grid ne sont pas pris en charge en mode natif dans un environnement App Service Environment (ASE) d’équilibreur de charge interne. Le déclencheur utilise une requête HTTP qui ne peut pas atteindre l’application de fonction sans passerelle dans le réseau virtuel.

Important

Cet article utilise des onglets pour prendre en charge plusieurs versions du modèle de programmation Node.js. Le modèle v4 est en disponibilité générale. Il est conçu pour offrir une expérience plus flexible et intuitive aux développeurs JavaScript et TypeScript. Pour plus d’informations sur le fonctionnement du modèle v4, reportez-vous au guide du développeur Azure Functions Node.js. Pour plus d’informations sur les différences entre v3 et v4, consultez le guide de migration.

Azure Functions prend en charge deux modèles de programmation pour Python. La façon dont vous définissez vos liaisons dépend du modèle de programmation choisi.

Le modèle de programmation Python v2 vous permet de définir des liaisons à l'aide d’éléments décoratifs directement dans le code de votre fonction Python. Pour plus d’informations, consultez le guide des développeurs Python.

Cet article prend en compte les deux modèles de programmation.

Exemple

Pour obtenir un exemple de déclencheur HTTP, consultez Recevoir des événements sur un point de terminaison HTTP.

Le type du paramètre d’entrée utilisé avec un déclencheur Event Grid dépend de ces trois facteurs :

Version du runtime Functions
Version de l’extension de liaison
Modalité de la fonction C#.

Une fonction C# peut être créée à l’aide de l’un des modes C# suivants :

Modèle worker isolé : fonction C# compilée exécutée dans un processus worker isolé du runtime. Le processus Worker isolé est requis pour prendre en charge les fonctions C# exécutées sur les versions LTS et non-LTS de .NET et de .NET Framework. Les extensions pour les fonctions de processus de travail isolés utilisent des espaces de noms Microsoft.Azure.Functions.Worker.Extensions.*.
Modèle In-process : fonction C# compilée exécutée dans le même processus que le runtime Functions. Dans une variation de ce modèle, Functions peut être exécuté à l’aide de scripts C#, principalement pris en charge pour la modification du portail C#. Les extensions pour les fonctions in-process utilisent des espaces de noms Microsoft.Azure.WebJobs.Extensions.*.

Important

La prise en charge du modèle in-process prendra fin le 10 novembre 2026. Pour continuer à bénéficier d’une prise en charge complète, nous vous recommandons vivement de migrer vos applications vers le modèle worker isolé.

Modèle de worker isolé
Modèle in-process

Quand vous exécutez votre fonction C# dans un processus Worker isolé, vous devez définir un type personnalisé pour les propriétés d’événement. L’exemple suivant définit une classe MyEventType.


        public string? Topic { get; set; }

        public string? Subject { get; set; }

        public string? EventType { get; set; }

        public DateTime EventTime { get; set; }

        public IDictionary<string, object>? Data { get; set; }
    }
}

L’exemple suivant montre l’utilisation du type personnalisé à la fois dans le déclencheur et dans une liaison de sortie Event Grid :

    [Function(nameof(EventGridFunction))]
    [EventGridOutput(TopicEndpointUri = "MyEventGridTopicUriSetting", TopicKeySetting = "MyEventGridTopicKeySetting")]
    public static MyEventType Run([EventGridTrigger] MyEventType input, FunctionContext context)
    {
        var logger = context.GetLogger(nameof(EventGridFunction));
        logger.LogInformation(input.Data?.ToString());

        var outputEvent = new MyEventType()
        {
            Id = "unique-id",
            Subject = "abc-subject",
            Data = new Dictionary<string, object>
            {
                { "myKey", "myValue" }
            }
        };

        return outputEvent;
    }
}

public class MyEventType
{

L’exemple suivant montre une fonction Functions version 4.x qui utilise un paramètre de liaison CloudEvent :

using Azure.Messaging;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public static class CloudEventTriggerFunction
    {
        [FunctionName("CloudEventTriggerFunction")]
        public static void Run(
            ILogger logger,
            [EventGridTrigger] CloudEvent e)
        {
            logger.LogInformation("Event received {type} {subject}", e.Type, e.Subject);
        }
    }
}

L’exemple suivant montre une fonction Functions version 4.x qui utilise un paramètre de liaison EventGridEvent :

using Microsoft.Azure.WebJobs;
using Azure.Messaging.EventGrid;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public static class EventGridTriggerDemo
    {
        [FunctionName("EventGridTriggerDemo")]
        public static void Run([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
        {
            log.LogInformation(eventGridEvent.Data.ToString());
        }
    }
}

L’exemple suivant montre une fonction qui utilise un paramètre de liaison JObject :

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public static class EventGridTriggerCSharp
    {
        [FunctionName("EventGridTriggerCSharp")]
        public static void Run([EventGridTrigger] JObject eventGridEvent, ILogger log)
        {
            log.LogInformation(eventGridEvent.ToString(Formatting.Indented));
        }
    }
}

Cette section contient les exemples suivants :

Déclencheur Event Grid, paramètre String
Déclencheur Event Grid, paramètre POJO

Les exemples suivants illustrent la liaison de déclencheur en Java. Ils utilisent la liaison et génèrent un événement, en recevant d’abord l’événement en tant que String puis en tant que POJO.

Déclencheur Event Grid, paramètre String

  @FunctionName("eventGridMonitorString")
  public void logEvent(
    @EventGridTrigger(
      name = "event"
    )
    String content,
    final ExecutionContext context) {
      context.getLogger().info("Event content: " + content);
  }

Déclencheur Event Grid, paramètre POJO

Cet exemple utilise le POJO suivant, représentant les propriétés de niveau supérieur d’un événement Event Grid :

import java.util.Date;
import java.util.Map;

public class EventSchema {

  public String topic;
  public String subject;
  public String eventType;
  public Date eventTime;
  public String id;
  public String dataVersion;
  public String metadataVersion;
  public Map<String, Object> data;

}

À l’arrivée, la charge utile JSON de l’événement est désérialisée dans le POJO EventSchema pour une utilisation par la fonction. Ce processus permet à la fonction d'accéder aux propriétés de l'événement selon une approche orientée objet.

  @FunctionName("eventGridMonitor")
  public void logEvent(
    @EventGridTrigger(
      name = "event"
    )
    EventSchema event,
    final ExecutionContext context) {
      context.getLogger().info("Event content: ");
      context.getLogger().info("Subject: " + event.subject);
      context.getLogger().info("Time: " + event.eventTime); // automatically converted to Date by the runtime
      context.getLogger().info("Id: " + event.id);
      context.getLogger().info("Data: " + event.data);
  }

Dans la bibliothèque du runtime des fonctions Java, utilisez l’annotation EventGridTrigger sur les paramètres dont la valeur proviendrait d’Event Grid. Les paramètres ayant ces annotations entraînent l’exécution de la fonction quand un événement se produit. Vous pouvez utiliser cette annotation avec des types Java natifs, des objets POJO ou des valeurs Null à l’aide de Optional<T>.

Modèle v4
Modèle v3

L’exemple suivant montre une fonction TypeScript du déclencheur d’une grille d’événements.

import { app, EventGridEvent, InvocationContext } from '@azure/functions';

export async function eventGridTrigger1(event: EventGridEvent, context: InvocationContext): Promise<void> {
    context.log('Event grid function processed event:', event);
}

app.eventGrid('eventGridTrigger1', {
    handler: eventGridTrigger1,
});

Modèle v4
Modèle v3

L’exemple suivant montre une fonction JavaScript du déclencheur d’une grille d’événements.

const { app } = require('@azure/functions');

app.eventGrid('eventGridTrigger1', {
    handler: (event, context) => {
        context.log('Event grid function processed event:', event);
    },
});

L’exemple suivant montre une liaison de déclencheur dans un fichier function.json et une fonction JavaScript qui utilise la liaison.

Voici les données de liaison dans le fichier function.json :

{
  "bindings": [
    {
      "type": "eventGridTrigger",
      "name": "eventGridEvent",
      "direction": "in"
    }
  ],
  "disabled": false
}

Voici le code JavaScript :

module.exports = async function (context, eventGridEvent) {
    context.log("JavaScript Event Grid function processed a request.");
    context.log("Subject: " + eventGridEvent.subject);
    context.log("Time: " + eventGridEvent.eventTime);
    context.log("Data: " + JSON.stringify(eventGridEvent.data));
};

L’exemple suivant montre comment configurer une liaison de déclencheur Event Grid dans le fichier function.json.

{
  "bindings": [
    {
      "type": "eventGridTrigger",
      "name": "eventGridEvent",
      "direction": "in"
    }
  ]
}

L’événement Event Grid est rendu accessible à la fonction par un paramètre nommé eventGridEvent, comme le montre l’exemple PowerShell suivant.

param($eventGridEvent, $TriggerMetadata)

# Make sure to pass hashtables to Out-String so they're logged correctly
$eventGridEvent | Out-String | Write-Host

L'exemple suivant présente une liaison de déclencheur Event Grid et une fonction Python qui utilise la liaison. L’exemple varie selon que vous utilisez le modèle de programmation Python v1 ou v2.

import logging
import json
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="eventGridTrigger")
@app.event_grid_trigger(arg_name="event")
def eventGridTest(event: func.EventGridEvent):
    result = json.dumps({
        'id': event.id,
        'data': event.get_json(),
        'topic': event.topic,
        'subject': event.subject,
        'event_type': event.event_type,
    })

    logging.info('Python EventGrid trigger processed an event: %s', result)

Voici les données de liaison dans le fichier function.json :

{
  "bindings": [
    {
      "type": "eventGridTrigger",
      "name": "event",
      "direction": "in"
    }
  ],
  "disabled": false,
  "scriptFile": "__init__.py"
}

Voici le code Python :

import json
import logging

import azure.functions as func

def main(event: func.EventGridEvent):

    result = json.dumps({
        'id': event.id,
        'data': event.get_json(),
        'topic': event.topic,
        'subject': event.subject,
        'event_type': event.event_type,
    })

    logging.info('Python EventGrid trigger processed an event: %s', result)

Attributs

Les bibliothèques C# in-process et de processus Worker isolé utilisent l’attribut EventGridTrigger. Le script C# utilise à la place un fichier de configuration function.json comme décrit dans le guide de script C#.

Modèle de worker isolé
Modèle in-process

Voici un attribut EventGridTrigger dans une signature de méthode :

public static MyEventType Run([EventGridTrigger] MyEventType input, FunctionContext context)
{
    var logger = context.GetLogger(nameof(EventGridFunction));
    logger.LogInformation(input.Data?.ToString());

Voici un attribut EventGridTrigger dans une signature de méthode :

[FunctionName("EventGridTest")]
public static void EventGridTest([EventGridTrigger] JObject eventGridEvent, ILogger log)
{

Annotations

L’annotation EventGridTrigger vous permet de configurer de façon déclarative une liaison Event Grid en fournissant des valeurs de configuration. Pour plus d’informations, consultez les sections Exemple et Configuration.

L’objet options passé à la méthode app.eventGrid() ne prend actuellement en charge aucune propriété pour le modèle v4.

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le fichier function.json.

Propriété	Description
type	Obligatoire : doit être défini sur `eventGridTrigger`.
direction	Obligatoire : doit être défini sur `in`.
name	Obligatoire : nom de variable utilisé dans le code de fonction pour le paramètre qui reçoit les données de l’événement.

Configuration

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le fichier function.json. Il n’y a aucun paramètre de constructeur ni aucune propriété à définir dans l’attribut EventGridTrigger.

Propriété function.json	Description
type	Obligatoire : doit être défini sur `eventGridTrigger`.
direction	Obligatoire : doit être défini sur `in`.
name	Obligatoire : nom de variable utilisé dans le code de fonction pour le paramètre qui reçoit les données de l’événement.

Pour obtenir des exemples complets, consultez la section Exemple.

Utilisation

Le déclencheur Event Grid utilise une requête HTTP webhook, qui peut être configurée à l’aide des mêmes paramètres host.json que le déclencheur HTTP.

Le type de paramètre pris en charge par le déclencheur Event Grid dépend de la version du runtime Functions, de la version du package d’extension et de la modalité C# utilisée.

Lorsque vous souhaitez que la fonction traite un seul événement, le déclencheur Event Grid peut se lier aux types suivants :

Type	Description
Types sérialisables JSON	Functions tente de désérialiser les données JSON de l’événement dans un type d’objet POCO (Plain-Old CLR Object).
`string`	Événement sous forme de chaîne.
BinaryData¹	Octets du message de l’événement.
CloudEvent¹	Objet événement. À utiliser quand Event Grid est configuré pour la livraison à l’aide du schéma CloudEvents.
EventGridEvent¹	Objet événement. À utiliser quand Event Grid est configuré pour la livraison à l’aide du schéma Event Grid.

Quand vous souhaitez que la fonction traite un lot d’événements, le déclencheur Event Grid peut se lier aux types suivants :

Type	Description
`CloudEvent[]`¹, `EventGridEvent[]`¹, `string[]`, `BinaryData[]`¹	Tableau d’événements du lot. Chaque entrée représente un événement.

¹ Pour utiliser ces types, vous devez référencer Microsoft.Azure.Functions.Worker.Extensions.EventGrid 3.3.0 ou version ultérieure et les dépendances courantes pour les liaisons de type kit de développement logiciel (SDK).

L’instance d’événement Event Grid est disponible via le paramètre associé à l’attribut EventGridTrigger, typé en EventSchema.

L’instance Event Grid est disponible via le paramètre configuré dans la propriété name du fichier function.json.

L’instance Event Grid est disponible via le paramètre configuré dans la propriété name du fichier function.json, typée en func.EventGridEvent.

Schéma d’événement

Les données d’un événement Event Grid sont réceptionnées sous la forme d’un objet JSON dans le corps d’une requête HTTP, comme dans l’exemple suivant :

[{
  "topic": "/subscriptions/{subscriptionid}/resourceGroups/eg0122/providers/Microsoft.Storage/storageAccounts/egblobstore",
  "subject": "/blobServices/default/containers/{containername}/blobs/blobname.jpg",
  "eventType": "Microsoft.Storage.BlobCreated",
  "eventTime": "2018-01-23T17:02:19.6069787Z",
  "id": "{guid}",
  "data": {
    "api": "PutBlockList",
    "clientRequestId": "{guid}",
    "requestId": "{guid}",
    "eTag": "0x8D562831044DDD0",
    "contentType": "application/octet-stream",
    "contentLength": 2248,
    "blobType": "BlockBlob",
    "url": "https://egblobstore.blob.core.windows.net/{containername}/blobname.jpg",
    "sequencer": "000000000000272D000000000003D60F",
    "storageDiagnostics": {
      "batchId": "{guid}"
    }
  },
  "dataVersion": "",
  "metadataVersion": "1"
}]

Cet exemple est un tableau comportant un seul élément. Event Grid envoie toujours un tableau et peut y inclure plusieurs événements. Le runtime appelle la fonction une fois par élément du tableau.

Les propriétés de niveau supérieur présentes dans les données JSON de l’événement sont les mêmes quel que soit le type d’événement, tandis que la valeur de la propriété data est propre à chaque type d’événement. L’exemple correspond à un événement de Stockage Blob.

Vous trouverez des explications sur les propriétés communes et propres aux événements dans la section Propriétés des événements de la documentation Event Grid.

Étapes suivantes

Si vous avez des questions, envoyez un problème à l’équipe ici
Distribuer un événement Event Grid

Partage via

Déclencheur Azure Event Grid pour Azure Functions

Exemple

Déclencheur Event Grid, paramètre String

Déclencheur Event Grid, paramètre POJO

Attributs

Annotations

Configuration

Configuration

Utilisation

Schéma d’événement

Étapes suivantes

Commentaires

Ressources supplémentaires