Dela via

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

  • Artikel

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.

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.

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.

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 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:

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

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

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

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

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

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.

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)

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.

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

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

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

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

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.

Förbrukning

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.

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.

1 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.

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