Azure Event Grid-Trigger für Azure Functions

Mit dem Python v2-Programmiermodell können Sie Bindungen mithilfe von Decorators direkt im Python-Funktionscode definieren. Weitere Informationen finden Sie im Python Developer-Leitfaden.

Für das Python v1-Programmiermodell müssen Sie Bindungen in einer separaten function.json-Datei im Funktionsordner definieren. Weitere Informationen finden Sie im Python Developer-Leitfaden.

Wenn Sie Ihre C#-Funktion in einem isolierten Workerprozess ausführen, müssen Sie einen benutzerdefinierten Typ für Ereigniseigenschaften definieren. Im folgenden Beispiel wird eine Klasse vom Typ MyEventType definiert:

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

Das folgende Beispiel zeigt, wie der benutzerdefinierte Typ sowohl im Trigger als auch in einer Event Grid-Ausgabebindung verwendet wird:

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

Das folgende Beispiel zeigt eine Funktion von Functions Version 4.x, die einen Bindungsparameter vom Typ CloudEvent verwendet:

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

Das folgende Beispiel zeigt eine Funktion von Functions Version 4.x, die einen Bindungsparameter vom Typ EventGridEvent verwendet:

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

Das folgende Beispiel zeigt eine Funktion mit einem Bindungsparameter vom Typ 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));
        }
    }
}

Das folgende Beispiel zeigt eine TypeScript-Funktion für den Event Grid-Trigger.

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

TypeScript-Beispiele sind für Modell v3 nicht dokumentiert.

Das folgende Beispiel zeigt eine JavaScript-Funktion für den Event Grid-Trigger.

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

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

Das folgende Beispiel zeigt eine Triggerbindung in einer Datei function.json sowie eine JavaScript-Funktion, die die Bindung verwendet.

Bindungsdaten in der Datei function.json:

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

Der JavaScript-Code sieht wie folgt aus:

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)

Bindungsdaten in der Datei function.json:

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

Dies ist der Python-Code:

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)

Dies ist ein EventGridTrigger-Attribut in einer Methodensignatur:

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

Dies ist ein EventGridTrigger-Attribut in einer Methodensignatur:

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

Das an die app.eventGrid()-Methode übergebene options-Objekt unterstützt derzeit keine Eigenschaften für das Modell v4.

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften, die Sie in der Datei function.json festlegen.

Von In-Process-C#-Klassenbibliotheksfunktionen werden die folgenden Typen unterstützt:

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

Von In-Process-C#-Klassenbibliotheksfunktionen werden die folgenden Typen unterstützt:

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

Von In-Process-C#-Klassenbibliotheksfunktionen werden die folgenden Typen unterstützt:

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

Wenn die Funktion ein einzelnes Ereignis verarbeiten soll, kann der Event Grid-Trigger an die folgenden Typen gebunden werden:

Wenn die Funktion einen Ereignisbatch verarbeiten soll, kann der Event Grid-Trigger an die folgenden Typen gebunden werden:

¹ Um diese Typen zu verwenden, müssen Sie auf Microsoft.Azure.Functions.Worker.Extensions.EventGrid 3.3.0 oder höher und die gemeinsamen Abhängigkeiten für SDK-Typbindungen verweisen.

Erfordert die Definition eines benutzerdefinierten Typs oder die Verwendung einer Zeichenfolge. Beispiele für die Verwendung eines benutzerdefinierten Parametertyps finden Sie im Abschnitt Beispiel.

Die Azure Functions-Version 1.x unterstützt nicht den isolierten Workerprozess.