Azure Event Grid-utlösare för Azure Functions

Använd funktionsutlösaren för att svara på en händelse som skickas av en Event Grid-källa. Du måste ha en händelseprenumeration på källan för att kunna ta emot händelser. Information om hur du skapar en händelseprenumeration finns i Skapa en prenumeration. Mer information om konfiguration och konfiguration av bindningar finns i översikten.

Kommentar

Event Grid-utlösare stöds inte internt i en intern lastbalanserare App Service-miljön (ASE). Utlösaren använder en HTTP-begäran som inte kan nå funktionsappen utan en gateway till det virtuella nätverket.

Viktigt!

Den här artikeln använder flikar för att stödja flera versioner av Node.js programmeringsmodellen. V4-modellen är allmänt tillgänglig och är utformad för att ha en mer flexibel och intuitiv upplevelse för JavaScript- och TypeScript-utvecklare. Mer information om hur v4-modellen fungerar finns i utvecklarguiden för Azure Functions Node.js. Mer information om skillnaderna mellan v3 och v4 finns i migreringsguiden.

Azure Functions stöder två programmeringsmodeller för Python. Hur du definierar dina bindningar beror på din valda programmeringsmodell.

v2

Med programmeringsmodellen Python v2 kan du definiera bindningar med hjälp av dekoratörer direkt i python-funktionskoden. Mer information finns i utvecklarguiden för Python.

v1

Programmeringsmodellen Python v1 kräver att du definierar bindningar i en separat function.json fil i funktionsmappen. Mer information finns i utvecklarguiden för Python.

Den här artikeln stöder båda programmeringsmodellerna.

Exempel

Ett EXEMPEL på HTTP-utlösare finns i Ta emot händelser till en HTTP-slutpunkt.

Vilken typ av indataparameter som används med en Event Grid-utlösare beror på följande tre faktorer:

• Funktionskörningsversion
• Bindningstilläggsversion
• Modalitet för C#-funktionen.

En C#-funktion kan skapas med något av följande C#-lägen:

• Isolerad arbetsmodell: Kompilerad C#-funktion som körs i en arbetsprocess som är isolerad från körningen. Isolerad arbetsprocess krävs för att stödja C#-funktioner som körs på LTS- och icke-LTS-versioner .NET och .NET Framework. Tillägg för isolerade arbetsprocessfunktioner använder Microsoft.Azure.Functions.Worker.Extensions.* namnområden.
• Processmodell: Kompilerad C#-funktion som körs i samma process som Functions-körningen. I en variant av den här modellen kan Functions köras med C#-skript, vilket främst stöds för redigering av C#-portalen. Tillägg för in-process-funktioner använder Microsoft.Azure.WebJobs.Extensions.* namnområden.

Viktigt!

Supporten upphör för den pågående modellen den 10 november 2026. Vi rekommenderar starkt att du migrerar dina appar till den isolerade arbetsmodellen för fullt stöd.

Isolerad arbetsmodell

När du kör C#-funktionen i en isolerad arbetsprocess måste du definiera en anpassad typ för händelseegenskaper. I följande exempel definieras en MyEventType klass.

    public class MyEventType
    {
        public string Id { get; set; }

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

I följande exempel visas hur den anpassade typen används i både utlösaren och en Event Grid-utdatabindning:

public static class EventGridFunction
{
    [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;
    }
}

Processmodell

I följande exempel visas en Funktion version 4.x-funktion som använder en CloudEvent bindningsparameter:

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

I följande exempel visas funktionen Functions version 4.x som använder en bindningsparameter 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());
        }
    }
}

I följande exempel visas en funktion som använder en JObject bindningsparameter:

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

Det här avsnittet innehåller följande exempel:

• Event Grid-utlösare, strängparameter
• Event Grid-utlösare, POJO-parameter

I följande exempel visas utlösarbindning i Java som använder bindningen och genererar en händelse, som först tar emot händelsen som String och sedan som en POJO.

Event Grid-utlösare, strängparameter

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

Event Grid-utlösare, POJO-parameter

I det här exemplet används följande POJO som representerar egenskaperna på den översta nivån för en Event Grid-händelse:

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;

}

Vid ankomsten tas händelsens JSON-nyttolast bort till EventSchema POJO för användning av funktionen. Med den här processen kan funktionen komma åt händelsens egenskaper på ett objektorienterat sätt.

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

I Java Functions-körningsbiblioteket använder du anteckningen EventGridTrigger för parametrar vars värde skulle komma från Event Grid. Parametrar med dessa anteckningar gör att funktionen körs när en händelse kommer. Den här anteckningen kan användas med interna Java-typer, POJO:er eller null-värden med hjälp av Optional<T>.

Modell v4

I följande exempel visas en TypeScript-funktion för utlösare för händelserutnät.

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

Modell v3

TypeScript-exempel dokumenteras inte för modell v3.

Modell v4

I följande exempel visas en JavaScript-funktion för utlösare för händelserutnät.

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

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

Modell v3

I följande exempel visas en utlösarbindning i en function.json-fil och en JavaScript-funktion som använder bindningen.

Här är bindningsdata i filen function.json :

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

Här är JavaScript-koden:

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

I följande exempel visas hur du konfigurerar en Event Grid-utlösarbindning i filen function.json .

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

Event Grid-händelsen görs tillgänglig för funktionen via en parameter med namnet eventGridEvent, enligt följande PowerShell-exempel.

param($eventGridEvent, $TriggerMetadata)

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

I följande exempel visas en Event Grid-utlösarbindning och en Python-funktion som använder bindningen. Exemplet beror på om du använder python-programmeringsmodellen v1 eller v2.

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)

v1

Här är bindningsdata i filen function.json :

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

Här är Python-koden:

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)

Attribut

C#-biblioteken för både processer och isolerade arbetsprocesser använder attributet EventGridTrigger . C#-skriptet använder i stället en function.json konfigurationsfil enligt beskrivningen i C#-skriptguiden.

Isolerad arbetsmodell

Här är ett EventGridTrigger attribut i en metodsignatur:

[Function(nameof(EventGridFunction))]
[EventGridOutput(TopicEndpointUri = "MyEventGridTopicUriSetting", TopicKeySetting = "MyEventGridTopicKeySetting")]
public static MyEventType Run([EventGridTrigger] MyEventType input, FunctionContext context)
{

Processmodell

Här är ett EventGridTrigger attribut i en metodsignatur:

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

Kommentarer

Med EventGridTrigger-kommentaren kan du deklarativt konfigurera en Event Grid-bindning genom att ange konfigurationsvärden. Mer information finns i exempel- och konfigurationsavsnitten.

Konfiguration

Modell v4

Objektet options som skickas till app.eventGrid() metoden stöder för närvarande inte några egenskaper för modell v4.

Modell v3

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json .

Property	Beskrivning
typ	Obligatoriskt – måste anges till eventGridTrigger.
riktning	Obligatoriskt – måste anges till in.
Namn	Obligatoriskt – variabelnamnet som används i funktionskoden för parametern som tar emot händelsedata.

Konfiguration

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json . Det finns inga konstruktorparametrar eller egenskaper att ange i attributet EventGridTrigger .

function.json egenskap	beskrivning
typ	Obligatoriskt – måste anges till eventGridTrigger.
riktning	Obligatoriskt – måste anges till in.
Namn	Obligatoriskt – variabelnamnet som används i funktionskoden för parametern som tar emot händelsedata.

Se avsnittet Exempel för fullständiga exempel.

Användning

Event Grid-utlösaren använder en WEBHOOK HTTP-begäran som kan konfigureras med samma host.json inställningar som HTTP-utlösaren.

Vilken parametertyp som stöds av Event Grid-utlösaren beror på functions-körningsversionen, tilläggspaketversionen och den C#-modalitet som används.

Tillägg v3.x

C#-klassbiblioteksfunktionerna i processen stöder följande typer:

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

Tillägg v2.x

C#-klassbiblioteksfunktionerna i processen stöder följande typer:

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

Funktioner 1.x

C#-klassbiblioteksfunktionerna i processen stöder följande typer:

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

Tillägg v3.x

När du vill att funktionen ska bearbeta en enskild händelse kan Event Grid-utlösaren binda till följande typer:

Typ	Beskrivning
JSON-serialiserbara typer	Functions försöker deserialisera JSON-data för händelsen till en vanlig CLR-objekttyp (POCO).
string	Händelsen som en sträng.
BinaryData1	Byte för händelsemeddelandet.
CloudEvent1	Händelseobjektet. Använd när Event Grid har konfigurerats för att leverera med hjälp av CloudEvents-schemat.
EventGridEvent1	Händelseobjektet. Använd när Event Grid har konfigurerats för att leverera med event grid-schemat.

När du vill att funktionen ska bearbeta en batch med händelser kan Event Grid-utlösaren binda till följande typer:

Typ	Beskrivning
CloudEvent[]1, EventGridEvent[]1, string[], BinaryData[]1	En matris med händelser från batchen. Varje post representerar en händelse.

¹ Om du vill använda dessa typer måste du referera till Microsoft.Azure.Functions.Worker.Extensions.EventGrid 3.3.0 eller senare och de vanliga beroendena för SDK-typbindningar.

Tillägg v2.x

Kräver att du definierar en anpassad typ eller använder en sträng. I avsnittet Exempel finns exempel på hur du använder en anpassad parametertyp.

Funktioner 1.x

Functions version 1.x stöder inte den isolerade arbetsprocessen.

Event Grid-händelseinstansen är tillgänglig via parametern som är associerad med EventGridTrigger attributet, skrivet som en EventSchema.

Event Grid-instansen är tillgänglig via parametern som konfigurerats i function.json-filens name egenskap.

Event Grid-instansen är tillgänglig via parametern som konfigurerats i function.json-filens name egenskap, skrivet som func.EventGridEvent.

Händelseschema

Data för en Event Grid-händelse tas emot som ett JSON-objekt i brödtexten i en HTTP-begäran. JSON ser ut ungefär som i följande exempel:

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

Exemplet som visas är en matris med ett element. Event Grid skickar alltid en matris och kan skicka fler än en händelse i matrisen. Körningen anropar funktionen en gång för varje matriselement.

Egenskaperna på den översta nivån i händelse-JSON-data är desamma bland alla händelsetyper, medan innehållet i data egenskapen är specifikt för varje händelsetyp. Exemplet som visas är för en bloblagringshändelse.

Förklaringar av de vanliga och händelsespecifika egenskaperna finns i Händelseegenskaper i Event Grid-dokumentationen.

Nästa steg

• Om du har frågor skickar du ett problem till teamet här
• Skicka en Event Grid-händelse