Déclencheur Azure Event Grid pour Azure Functions

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.

Le modèle de programmation Python v1 vous oblige à définir des liaisons dans un fichier function.json distinct dans le dossier de fonction. Pour plus d’informations, consultez le guide des développeurs Python.

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));
        }
    }
}

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,
});

Les exemples TypeScript ne sont pas documentés pour le 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));
};

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)

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)
{

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.

Les fonctions de la bibliothèque de classes C# In-process prennent en charge les types suivants :

• Azure.Messaging.CloudEvent
• Azure.Messaging.EventGrid
• Newtonsoft.Json.Linq.JObject
• System.String

Les fonctions de la bibliothèque de classes C# In-process prennent en charge les types suivants :

• Microsoft.Azure.EventGrid.Models.EventGridEvent
• Newtonsoft.Json.Linq.JObject
• System.String

Les fonctions de la bibliothèque de classes C# In-process prennent en charge les types suivants :

• Newtonsoft.Json.Linq.JObject
• System.String

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

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

¹ 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).

Requiert la définition d’un type personnalisé ou l’utilisation d’une chaîne. Pour obtenir des exemples d’utilisation d’un type de paramètre personnalisé, consultez la section Exemple.

La version 1.x de Functions ne prend pas en charge le processus Worker isolé.