Azure Event Grid-eseményindító az Azure Functionshez

A függvényindítóval válaszolhat egy Event Grid-forrás által küldött eseményre. Az események fogadásához esemény-előfizetéssel kell rendelkeznie a forráshoz. Az esemény-előfizetések létrehozásáról az előfizetés létrehozása című témakörben olvashat. A kötések beállításával és konfigurálásának ismertetésével kapcsolatban tekintse meg az áttekintést.

Feljegyzés

Az Event Grid-eseményindítók natív módon nem támogatottak egy belső terheléselosztó App Service-környezetben (ASE). Az eseményindító olyan HTTP-kérést használ, amely nem éri el a függvényalkalmazást átjáró nélkül a virtuális hálózatba.

Fontos

Ez a cikk lapokat használ a Node.js programozási modell több verziójának támogatásához. A v4-modell általánosan elérhető, és úgy lett kialakítva, hogy rugalmasabb és intuitívabb felhasználói élményt nyújtson JavaScript- és TypeScript-fejlesztők számára. A v4-modell működésével kapcsolatos további információkért tekintse meg az Azure Functions Node.js fejlesztői útmutatóját. A v3 és a v4 közötti különbségekről a migrálási útmutatóban olvashat bővebben.

Az Azure Functions két Python-programozási modellt támogat. A kötések definiálásának módja a választott programozási modelltől függ.

v2

A Python v2 programozási modell lehetővé teszi, hogy a kötéseket dekorátorokkal definiálja közvetlenül a Python-függvénykódban. További információt a Python fejlesztői útmutatójában talál.

v1

A Python v1 programozási modell megköveteli, hogy a függvénymappában egy külön function.json fájlban definiáljon kötéseket. További információt a Python fejlesztői útmutatójában talál.

Ez a cikk mindkét programozási modellt támogatja.

Példa

HTTP-eseményindító példa: Események fogadása HTTP-végpontra.

Az Event Grid-eseményindítókhoz használt bemeneti paraméter típusa az alábbi három tényezőtől függ:

• Functions futtatókörnyezet verziója
• Kötésbővítmény verziója
• A C# függvény modalitása.

A C#-függvények a következő C#-módok egyikével hozhatók létre:

• Izolált feldolgozómodell: Lefordított C# függvény, amely a futtatókörnyezettől elkülönített feldolgozói folyamatban fut. Izolált feldolgozói folyamat szükséges az LTS- és nem LTS-verziókon futó C#-függvények támogatásához .NET és .NET-keretrendszer. Az izolált feldolgozói folyamatfüggvények bővítményei névtereket használnak Microsoft.Azure.Functions.Worker.Extensions.* .
• Folyamaton belüli modell: Lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet. A modell egy változatában a Functions C#-szkriptekkel futtatható, amely elsősorban a C#-portál szerkesztéséhez támogatott. A folyamaton belüli függvények bővítményei névtereket használnak Microsoft.Azure.WebJobs.Extensions.* .

Fontos

A folyamaton belüli modell támogatása 2026. november 10-én megszűnik. Erősen javasoljuk, hogy az alkalmazásokat az elkülönített feldolgozói modellbe migrálja a teljes támogatás érdekében.

Izolált feldolgozói modell

Ha a C# függvényt izolált feldolgozófolyamatban futtatja, egyéni típust kell definiálnia az eseménytulajdonságokhoz. Az alábbi példa egy osztályt MyEventType határoz meg.

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

Az alábbi példa bemutatja, hogyan használja az egyéni típust az eseményindító és az Event Grid kimeneti kötése:

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

Folyamaton belüli modell

Az alábbi példa egy 4.x-es verziójú függvényt mutat be, amely kötési paramétert CloudEvent használ:

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

Az alábbi példa egy 4.x-es verziójú függvényt mutat be, amely kötési paramétert EventGridEvent használ:

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

Az alábbi példa egy kötési paramétert használó függvényt JObject mutat be:

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

Ez a szakasz a következő példákat tartalmazza:

• Event Grid-eseményindító, Sztring paraméter
• Event Grid-eseményindító, POJO paraméter

Az alábbi példák a javai eseményindító kötést mutatják be, amelyek a kötést használják, és létrehoznak egy eseményt, először poJO-ként fogadják az eseménytString, a másodikat pedig poJO-ként.

Event Grid-eseményindító, Sztring paraméter

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

Event Grid-eseményindító, POJO paraméter

Ez a példa a következő POJO-t használja, amely egy Event Grid-esemény legfelső szintű tulajdonságait jelöli:

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;

}

Érkezéskor az esemény JSON-hasznos adatai a függvény általi használat céljából deszerializálva lesznek a EventSchema POJO-ban. Ez a folyamat lehetővé teszi, hogy a függvény objektumorientált módon férhessen hozzá az esemény tulajdonságaihoz.

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

A Java-függvények futtatókörnyezeti kódtárában használja a széljegyzetet azon EventGridTrigger paramétereken, amelyek értéke az Event Gridből származna. Az ilyen széljegyzeteket tartalmazó paraméterek miatt a függvény egy esemény érkezésekor fut. Ez a széljegyzet natív Java-típusokkal, POJ-kkal vagy null értékű értékekkel használható a használatával Optional<T>.

Modell v4

Az alábbi példa egy event grid trigger TypeScript függvényt mutat be.

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

A TypeScript-minták nincsenek dokumentálva a v3-as modellhez.

Modell v4

Az alábbi példa egy Eseményrács eseményrács-trigger JavaScript-függvényét mutatja be.

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

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

Modell v3

Az alábbi példa egy triggerkötést mutat be egy function.json fájlban és egy JavaScript-függvényben , amely a kötést használja.

A kötési adatok a function.json fájlban:

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

A JavaScript-kód a következő:

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

Az alábbi példa bemutatja, hogyan konfigurálhat Event Grid-eseményindító-kötést a function.json fájlban.

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

Az Event Grid-esemény egy nevesített eventGridEventparaméteren keresztül érhető el a függvény számára, ahogyan az az alábbi PowerShell-példában is látható.

param($eventGridEvent, $TriggerMetadata)

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

Az alábbi példa egy Event Grid-eseményindító-kötést és egy Python-függvényt mutat be, amely a kötést használja. A példa attól függ, hogy a v1 vagy v2 Python programozási modellt használja-e.

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

A kötési adatok a function.json fájlban:

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

A Python-kód a következő:

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)

Attribútumok

A folyamaton belüli és az izolált feldolgozói folyamat C# kódtárai az EventGridTrigger attribútumot használják. A C#-szkript ehelyett egy function.json konfigurációs fájlt használ a C#-szkriptelési útmutatóban leírtak szerint.

Izolált feldolgozói modell

Íme egy EventGridTrigger attribútum egy metódus-aláírásban:

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

Folyamaton belüli modell

Íme egy EventGridTrigger attribútum egy metódus-aláírásban:

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

Jegyzetek

Az EventGridTrigger széljegyzet lehetővé teszi az Event Grid-kötés deklaratív konfigurálását konfigurációs értékek megadásával. További részletekért tekintse meg a példákat és a konfigurációs szakaszokat.

Konfiguráció

Modell v4

A options metódusnak app.eventGrid() átadott objektum jelenleg nem támogatja a 4. modell egyik tulajdonságát sem.

Modell v3

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

Tulajdonság	Leírás
type	Kötelező – a beállításnak eventGridTriggera következőnek kell lennie: .
direction	Kötelező – a beállításnak ina következőnek kell lennie: .
név	Kötelező – az eseményadatokat fogadó paraméter függvénykódjában használt változónév.

Konfiguráció

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti. Az attribútumban EventGridTrigger nincsenek konstruktorparaméterek vagy tulajdonságok.

function.json tulajdonság	Leírás
type	Kötelező – a beállításnak eventGridTriggera következőnek kell lennie: .
direction	Kötelező – a beállításnak ina következőnek kell lennie: .
név	Kötelező – az eseményadatokat fogadó paraméter függvénykódjában használt változónév.

A teljes példákért tekintse meg a Példa szakaszt .

Használat

Az Event Grid-eseményindító webhook HTTP-kérést használ, amely a HTTP-eseményindítóval azonos host.json beállításokkal konfigurálható.

Az Event Grid-eseményindító által támogatott paramétertípus a Functions futtatókörnyezet verziójától, a bővítménycsomag verziójától és a használt C# módtól függ.

V3.x kiterjesztés

A folyamatban lévő C# osztálykódtárfüggvények a következő típusokat támogatják:

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

V2.x kiterjesztés

A folyamatban lévő C# osztálykódtárfüggvények a következő típusokat támogatják:

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

Functions 1.x

A folyamatban lévő C# osztálykódtárfüggvények a következő típusokat támogatják:

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

V3.x kiterjesztés

Ha azt szeretné, hogy a függvény egyetlen eseményt dolgoz fel, az Event Grid-eseményindító a következő típusokhoz kapcsolódhat:

Típus	Leírás
JSON szerializálható típusok	A Functions megpróbálja deszerializálni az esemény JSON-adatait egy egyszerű régi CLR-objektum (POCO) típusba.
string	Az esemény sztringként.
BinaryData1	Az eseményüzenet bájtja.
CloudEvent1	Az eseményobjektum. Akkor használható, ha az Event Grid a CloudEvents sémával történő kézbesítésre van konfigurálva.
EventGridEvent1	Az eseményobjektum. Akkor használható, ha az Event Grid az Event Grid-sémával történő kézbesítésre van konfigurálva.

Ha azt szeretné, hogy a függvény feldolgozza az események kötegét, az Event Grid-eseményindító a következő típusokhoz köthet:

Típus	Leírás
CloudEvent[]1, EventGridEvent[]1, string[], BinaryData[]1	A kötegből származó események tömbje. Minden bejegyzés egy eseményt jelöl.

¹ Ezeknek a típusoknak a használatához hivatkoznia kell a Microsoft.Azure.Functions.Worker.Extensions.EventGrid 3.3.0-s vagy újabb verziójára, valamint az SDK-típuskötések gyakori függőségeire.

V2.x kiterjesztés

Egyéni típus definiálásához vagy sztring használatához van szükség. Az egyéni paramétertípus használatára példákat a Példa szakaszban talál.

Functions 1.x

A Functions 1.x-es verziója nem támogatja az izolált feldolgozói folyamatot.

Az Event Grid eseménypéldány az attribútumhoz EventGridTrigger társított paraméteren keresztül érhető el.EventSchema

Az Event Grid-példány a function.json fájl name tulajdonságában konfigurált paraméteren keresztül érhető el.

Az Event Grid-példány a function.json fájl name tulajdonságában konfigurált paraméteren keresztül érhető el, a következőként func.EventGridEventbegépelve: .

Eseményséma

Az Event Grid-esemény adatai JSON-objektumként érkeznek egy HTTP-kérés törzsébe. A JSON a következő példához hasonlóan néz ki:

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

A bemutatott példa egy elemből álló tömb. Az Event Grid mindig küld egy tömböt, és több eseményt is küldhet a tömbben. A futtatókörnyezet minden tömbelemhez egyszer meghívja a függvényt.

Az esemény JSON-adatainak legfelső szintű tulajdonságai minden eseménytípus esetében azonosak, míg a data tulajdonság tartalma minden eseménytípusra jellemző. A példa egy blobtároló eseményre mutat.

A gyakori és az eseményspecifikus tulajdonságok magyarázatát az Event Grid dokumentációjában található Eseménytulajdonságok című témakörben találja.

Következő lépések

• Ha kérdése van, küldje el a problémát a csapatnak itt
• Event Grid-esemény küldése