Wyzwalacz usługi Azure Event Grid dla usługi Azure Functions

Artykuł
11/21/2023

Użyj wyzwalacza funkcji, aby odpowiedzieć na zdarzenie wysyłane przez źródło usługi Event Grid. Aby odbierać zdarzenia, musisz mieć subskrypcję zdarzeń do źródła. Aby dowiedzieć się, jak utworzyć subskrypcję zdarzeń, zobacz Tworzenie subskrypcji. Aby uzyskać informacje na temat konfiguracji i konfiguracji powiązań, zobacz omówienie.

Uwaga

Wyzwalacze usługi Event Grid nie są natywnie obsługiwane w wewnętrznym środowisku App Service Environment (ASE). Wyzwalacz używa żądania HTTP, które nie może nawiązać połączenia z aplikacją funkcji bez bramy w sieci wirtualnej.

Ważne

W tym artykule są używane karty do obsługi wielu wersji modelu programowania Node.js. Model w wersji 4 jest ogólnie dostępny i ma bardziej elastyczne i intuicyjne środowisko dla deweloperów języka JavaScript i Języka TypeScript. Aby uzyskać więcej informacji na temat sposobu działania modelu w wersji 4, zapoznaj się z przewodnikiem dewelopera dotyczącym usługi Azure Functions Node.js. Aby dowiedzieć się więcej o różnicach między wersjami 3 i v4, zapoznaj się z przewodnikiem migracji.

Usługa Azure Functions obsługuje dwa modele programowania dla języka Python. Sposób definiowania powiązań zależy od wybranego modelu programowania.

Wersja 2
Wersja 1

Model programowania w języku Python w wersji 2 umożliwia definiowanie powiązań przy użyciu dekoratorów bezpośrednio w kodzie funkcji języka Python. Aby uzyskać więcej informacji, zobacz przewodnik dla deweloperów języka Python.

Ten artykuł obsługuje oba modele programowania.

Przykład

Aby zapoznać się z przykładem wyzwalacza HTTP, zobacz Odbieranie zdarzeń do punktu końcowego HTTP.

Typ parametru wejściowego używanego z wyzwalaczem usługi Event Grid zależy od następujących trzech czynników:

Wersja środowiska uruchomieniowego usługi Functions
Wersja rozszerzenia powiązania
Modalność funkcji języka C#.

Funkcję języka C# można utworzyć przy użyciu jednego z następujących trybów języka C#:

Model izolowanego procesu roboczego: skompilowana funkcja języka C#, która jest uruchamiana w procesie roboczym izolowanym od środowiska uruchomieniowego. Proces izolowanego procesu roboczego jest wymagany do obsługi funkcji języka C# uruchomionych w wersjach LTS i innych niż LTS platformy .NET oraz programu .NET Framework. Rozszerzenia dla izolowanych funkcji procesu roboczego używają Microsoft.Azure.Functions.Worker.Extensions.* przestrzeni nazw.
Model przetwarzania: skompilowana funkcja języka C#, która działa w tym samym procesie co środowisko uruchomieniowe usługi Functions. W odmianie tego modelu funkcje można uruchamiać przy użyciu skryptów języka C#, które są obsługiwane głównie w przypadku edytowania portalu języka C#. Rozszerzenia dla funkcji przetwarzania używają Microsoft.Azure.WebJobs.Extensions.* przestrzeni nazw.

Ważne

Wsparcie zostanie zakończone dla modelu procesu 10 listopada 2026 r. Zdecydowanie zalecamy przeprowadzenie migracji aplikacji do izolowanego modelu procesu roboczego w celu uzyskania pełnej obsługi.

Model izolowanego procesu roboczego
Model w procesie

Podczas uruchamiania funkcji języka C# w izolowanym procesie roboczym należy zdefiniować niestandardowy typ właściwości zdarzenia. W poniższym przykładzie zdefiniowano klasę MyEventType .

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

W poniższym przykładzie pokazano, jak typ niestandardowy jest używany zarówno w wyzwalaczu, jak i powiązaniu danych wyjściowych usługi Event Grid:

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

W poniższym przykładzie pokazano funkcję Functions w wersji 4.x, która używa parametru CloudEvent powiązania:

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

W poniższym przykładzie pokazano funkcję Functions w wersji 4.x, która używa parametru EventGridEvent powiązania:

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

W poniższym przykładzie pokazano funkcję, która używa parametru JObject powiązania:

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

Ta sekcja zawiera następujące przykłady:

Wyzwalacz usługi Event Grid, parametr ciągu
Wyzwalacz usługi Event Grid, parametr POJO

W poniższych przykładach pokazano powiązanie wyzwalacza w języku Java , które używa powiązania i generuje zdarzenie, najpierw odbierając zdarzenie jako String i drugą jako operację POJO.

Wyzwalacz usługi Event Grid, parametr ciągu

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

Wyzwalacz usługi Event Grid, parametr POJO

W tym przykładzie użyto następującego poJO reprezentującego właściwości najwyższego poziomu zdarzenia usługi 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;

}

Po przybyciu ładunek JSON zdarzenia jest zdeserializowany do EventSchema poJO do użytku przez funkcję . Ten proces umożliwia funkcji uzyskiwanie dostępu do właściwości zdarzenia w sposób obiektowy.

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

W bibliotece środowiska uruchomieniowego funkcji Języka Java użyj EventGridTrigger adnotacji parametrów, których wartość pochodzi z usługi Event Grid. Parametry z tymi adnotacjami powodują uruchomienie funkcji po nadejściu zdarzenia. Tej adnotacji można używać z natywnymi typami Języka Java, obiektami POJO lub wartościami dopuszczanymi wartościami null przy użyciu polecenia Optional<T>.

Model w wersji 4
Model w wersji 3

W poniższym przykładzie przedstawiono funkcję TypeScript wyzwalacza usługi Event Grid.

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

Model w wersji 4
Model w wersji 3

W poniższym przykładzie przedstawiono funkcję JavaScript wyzwalacza usługi Event Grid.

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

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

W poniższym przykładzie pokazano powiązanie wyzwalacza w pliku function.json i funkcję Języka JavaScript, która używa powiązania.

Oto dane powiązania w pliku function.json :

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

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

W poniższym przykładzie pokazano, jak skonfigurować powiązanie wyzwalacza usługi Event Grid w pliku function.json .

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

Zdarzenie usługi Event Grid jest udostępniane funkcji za pośrednictwem parametru o nazwie eventGridEvent, jak pokazano w poniższym przykładzie programu PowerShell.

param($eventGridEvent, $TriggerMetadata)

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

W poniższym przykładzie przedstawiono powiązanie wyzwalacza usługi Event Grid i funkcję języka Python, która używa powiązania. Przykład zależy od tego, czy używasz modelu programowania w wersji 1, czy w wersji 2 języka Python.

Wersja 2
Wersja 1

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)

Oto dane powiązania w pliku function.json :

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

Oto kod języka 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)

Atrybuty

Biblioteki języka C# procesu roboczego zarówno w procesie przetwarzania procesów procesowych, jak i izolowanych używają atrybutu EventGridTrigger. Zamiast tego skrypt języka C# używa pliku konfiguracji function.json zgodnie z opisem w przewodniku obsługi skryptów języka C#.

Model izolowanego procesu roboczego
Model w procesie

EventGridTrigger Oto atrybut w podpisie metody:

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

EventGridTrigger Oto atrybut w podpisie metody:

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

Adnotacje

Adnotacja EventGridTrigger umożliwia deklaratywne konfigurowanie powiązania usługi Event Grid przez podanie wartości konfiguracji. Aby uzyskać więcej szczegółów, zobacz sekcje przykładowe i konfiguracyjne .

Obiekt options przekazany do app.eventGrid() metody obecnie nie obsługuje żadnych właściwości modelu w wersji 4.

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

Właściwości	Opis
type	Wymagane — musi być ustawiona na `eventGridTrigger`wartość .
direction	Wymagane — musi być ustawiona na `in`wartość .
name	Required — nazwa zmiennej używana w kodzie funkcji dla parametru, który odbiera dane zdarzenia.

Konfigurowanie

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json . Brak parametrów konstruktora ani właściwości do ustawienia w atrybucie EventGridTrigger .

właściwość function.json	opis
type	Wymagane — musi być ustawiona na `eventGridTrigger`wartość .
direction	Wymagane — musi być ustawiona na `in`wartość .
name	Required — nazwa zmiennej używana w kodzie funkcji dla parametru, który odbiera dane zdarzenia.

Zobacz sekcję Przykład, aby zapoznać się z kompletnymi przykładami.

Użycie

Wyzwalacz usługi Event Grid używa żądania HTTP elementu webhook, które można skonfigurować przy użyciu tych samych ustawień host.json co wyzwalacz HTTP.

Typ parametru obsługiwany przez wyzwalacz usługi Event Grid zależy od wersji środowiska uruchomieniowego usługi Functions, wersji pakietu rozszerzenia i używanej modalności języka C#.

Jeśli chcesz, aby funkcja przetwarzała pojedyncze zdarzenie, wyzwalacz usługi Event Grid może powiązać z następującymi typami:

Type	Opis
Typy serializowalne w formacie JSON	Funkcje próbują wykonać deserializacji danych JSON zdarzenia w zwykły typ obiektu CLR (POCO).
`string`	Zdarzenie jako ciąg.
BinaryData¹	Bajty komunikatu zdarzenia.
CloudEvent¹	Obiekt zdarzenia. Użyj polecenia , gdy usługa Event Grid jest skonfigurowana do dostarczania przy użyciu schematu CloudEvents.
EventGridEvent¹	Obiekt zdarzenia. Użyj polecenia , gdy usługa Event Grid jest skonfigurowana do dostarczania przy użyciu schematu usługi Event Grid.

Jeśli chcesz, aby funkcja przetwarzała partię zdarzeń, wyzwalacz usługi Event Grid może powiązać z następującymi typami:

Type	Opis
`CloudEvent[]`¹, `EventGridEvent[]`¹, `string[]`, `BinaryData[]`¹	Tablica zdarzeń z partii. Każdy wpis reprezentuje jedno zdarzenie.

¹ Aby użyć tych typów, należy odwołać się do elementów Microsoft.Azure.Functions.Worker.Extensions.EventGrid 3.3.0 lub nowszych oraz typowych zależności dla powiązań typu zestawu SDK.

Wystąpienie zdarzenia usługi Event Grid jest dostępne za pośrednictwem parametru skojarzonego z atrybutem EventGridTrigger , wpisanego EventSchemajako .

Wystąpienie usługi Event Grid jest dostępne za pośrednictwem parametru skonfigurowanego we właściwości pliku name function.json.

Wystąpienie usługi Event Grid jest dostępne za pośrednictwem parametru skonfigurowanego we właściwości pliku name function.json, wpisanego jako func.EventGridEvent.

Schemat zdarzeń

Dane zdarzenia usługi Event Grid są odbierane jako obiekt JSON w treści żądania HTTP. Kod JSON wygląda podobnie do poniższego przykładu:

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

Pokazany przykład to tablica jednego elementu. Usługa Event Grid zawsze wysyła tablicę i może wysyłać więcej niż jedno zdarzenie w tablicy. Środowisko uruchomieniowe wywołuje funkcję raz dla każdego elementu tablicy.

Właściwości najwyższego poziomu w danych JSON zdarzenia są takie same we wszystkich typach zdarzeń, podczas gdy zawartość data właściwości jest specyficzna dla każdego typu zdarzenia. Pokazany przykład dotyczy zdarzenia magazynu obiektów blob.

Aby uzyskać wyjaśnienia typowych i specyficznych dla zdarzeń właściwości, zobacz Właściwości zdarzeń w dokumentacji usługi Event Grid.

Następne kroki

Jeśli masz pytania, prześlij problem do zespołu tutaj
Wysyłanie zdarzenia usługi Event Grid

Udostępnij za pośrednictwem

Wyzwalacz usługi Azure Event Grid dla usługi Azure Functions

Przykład

Wyzwalacz usługi Event Grid, parametr ciągu

Wyzwalacz usługi Event Grid, parametr POJO

Atrybuty

Adnotacje

Konfigurowanie

Konfigurowanie

Użycie

Schemat zdarzeń

Następne kroki

Opinia

Dodatkowe zasoby