Megosztás a következőn keresztül:


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.

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.

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

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

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

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

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

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

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.

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)

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.

Í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)
{

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ó

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

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.

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.

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

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