Azure Event Grid kimeneti kötés az Azure Functionshez

  • Cikk

Az Event Grid kimeneti kötésével eseményeket írhat egy egyéni témakörbe. Az egyéni témakörhöz érvényes hozzáférési kulccsal kell rendelkeznie. Az Event Grid kimeneti kötése nem támogatja a közös hozzáférésű jogosultságkódok (SAS) jogkivonatait.

A beállítási és konfigurációs részletekről további információt az Event Grid-eseményindítók és kötések használata az Azure Functionsben című témakörben talál.

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.

Fontos

Az Event Grid kimeneti kötése csak a Functions 2.x és újabb verziókhoz érhető el.

Példa

Az Event Grid kimeneti kötéshez használt kimeneti paraméter típusa a Functions futtatókörnyezet verziójától, a kötésbővítmény verziójától és a C# függvény modalitásától függ. A C# függvény a következő C#-módok egyikével hozható létre:

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:

using System;
using System.Collections.Generic;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace SampleApp
{
    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;
        }
    }

    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 egy Java-függvényt mutat be, amely üzenetet ír egy Event Grid-egyéni témakörbe. A függvény a kötés metódusával setValue ad ki egy sztringet.

public class Function {
    @FunctionName("EventGridTriggerTest")
    public void run(@EventGridTrigger(name = "event") String content,
            @EventGridOutput(name = "outputEvent", topicEndpointUri = "MyEventGridTopicUriSetting", topicKeySetting = "MyEventGridTopicKeySetting") OutputBinding<String> outputEvent,
            final ExecutionContext context) {
        context.getLogger().info("Java EventGrid trigger processed a request." + content);
        final String eventGridOutputDocument = "{\"id\": \"1807\", \"eventType\": \"recordInserted\", \"subject\": \"myapp/cars/java\", \"eventTime\":\"2017-08-10T21:03:07+00:00\", \"data\": {\"make\": \"Ducati\",\"model\": \"Monster\"}, \"dataVersion\": \"1.0\"}";
        outputEvent.setValue(eventGridOutputDocument);
    }
}

PoJO-osztályt is használhat Event Grid-üzenetek küldéséhez.

public class Function {
    @FunctionName("EventGridTriggerTest")
    public void run(@EventGridTrigger(name = "event") String content,
            @EventGridOutput(name = "outputEvent", topicEndpointUri = "MyEventGridTopicUriSetting", topicKeySetting = "MyEventGridTopicKeySetting") OutputBinding<EventGridEvent> outputEvent,
            final ExecutionContext context) {
        context.getLogger().info("Java EventGrid trigger processed a request." + content);

        final EventGridEvent eventGridOutputDocument = new EventGridEvent();
        eventGridOutputDocument.setId("1807");
        eventGridOutputDocument.setEventType("recordInserted");
        eventGridOutputDocument.setEventTime("2017-08-10T21:03:07+00:00");
        eventGridOutputDocument.setDataVersion("1.0");
        eventGridOutputDocument.setSubject("myapp/cars/java");
        eventGridOutputDocument.setData("{\"make\": \"Ducati\",\"model\":\"monster\"");

        outputEvent.setValue(eventGridOutputDocument);
    }
}

class EventGridEvent {
    private String id;
    private String eventType;
    private String subject;
    private String eventTime;
    private String dataVersion;
    private String data;

    public String getId() {
        return id;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public String getDataVersion() {
        return dataVersion;
    }

    public void setDataVersion(String dataVersion) {
        this.dataVersion = dataVersion;
    }

    public String getEventTime() {
        return eventTime;
    }

    public void setEventTime(String eventTime) {
        this.eventTime = eventTime;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public String getEventType() {
        return eventType;
    }

    public void setEventType(String eventType) {
        this.eventType = eventType;
    }

    public void setId(String id) {
        this.id = id;
    }  
}

Az alábbi példa egy időzítő által aktivált TypeScript-függvényt mutat be, amely egyetlen eseményt ad ki:

import { app, EventGridPartialEvent, InvocationContext, output, Timer } from '@azure/functions';

export async function timerTrigger1(myTimer: Timer, context: InvocationContext): Promise<EventGridPartialEvent> {
    const timeStamp = new Date().toISOString();
    return {
        id: 'message-id',
        subject: 'subject-name',
        dataVersion: '1.0',
        eventType: 'event-type',
        data: {
            name: 'John Henry',
        },
        eventTime: timeStamp,
    };
}

app.timer('timerTrigger1', {
    schedule: '0 */5 * * * *',
    return: output.eventGrid({
        topicEndpointUri: 'MyEventGridTopicUriSetting',
        topicKeySetting: 'MyEventGridTopicKeySetting',
    }),
    handler: timerTrigger1,
});

Több esemény kimenetéhez egyetlen objektum helyett egy tömböt kell visszaadnia. Példa:

const timeStamp = new Date().toISOString();
return [
    {
        id: 'message-id',
        subject: 'subject-name',
        dataVersion: '1.0',
        eventType: 'event-type',
        data: {
            name: 'John Henry',
        },
        eventTime: timeStamp,
    },
    {
        id: 'message-id-2',
        subject: 'subject-name',
        dataVersion: '1.0',
        eventType: 'event-type',
        data: {
            name: 'John Doe',
        },
        eventTime: timeStamp,
    },
];

Az alábbi példa egy időzítő által aktivált JavaScript-függvényt mutat be, amely egyetlen eseményt ad ki:

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

const eventGridOutput = output.eventGrid({
    topicEndpointUri: 'MyEventGridTopicUriSetting',
    topicKeySetting: 'MyEventGridTopicKeySetting',
});

app.timer('timerTrigger1', {
    schedule: '0 */5 * * * *',
    return: eventGridOutput,
    handler: (myTimer, context) => {
        const timeStamp = new Date().toISOString();
        return {
            id: 'message-id',
            subject: 'subject-name',
            dataVersion: '1.0',
            eventType: 'event-type',
            data: {
                name: 'John Henry',
            },
            eventTime: timeStamp,
        };
    },
});

Több esemény kimenetéhez egyetlen objektum helyett egy tömböt kell visszaadnia. Példa:

const timeStamp = new Date().toISOString();
return [
    {
        id: 'message-id',
        subject: 'subject-name',
        dataVersion: '1.0',
        eventType: 'event-type',
        data: {
            name: 'John Henry',
        },
        eventTime: timeStamp,
    },
    {
        id: 'message-id-2',
        subject: 'subject-name',
        dataVersion: '1.0',
        eventType: 'event-type',
        data: {
            name: 'John Doe',
        },
        eventTime: timeStamp,
    },
];

Az alábbi példa bemutatja, hogyan konfigurálhat függvényt egy Event Grid-eseményüzenet kimenetére. Az a szakasz, ahol type az Event Grid kimeneti kötés létrehozásához szükséges értékek konfigurálására van beállítva eventGrid .

{
  "bindings": [
    {
      "type": "eventGrid",
      "name": "outputEvent",
      "topicEndpointUri": "MyEventGridTopicUriSetting",
      "topicKeySetting": "MyEventGridTopicKeySetting",
      "direction": "out"
    },
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

A függvényben az Push-OutputBinding Event Grid kimeneti kötésével küldhet eseményt egy egyéni témakörnek.

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters or the body of the request.
$message = $Request.Query.Message

Push-OutputBinding -Name outputEvent -Value  @{
    id = "1"
    eventType = "testEvent"
    subject = "testapp/testPublish"
    eventTime = "2020-08-27T21:03:07+00:00"
    data = @{
        Message = $message
    }
    dataVersion = "1.0"
}

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = 200
    Body = "OK"
})

Az alábbi példa egy triggerkötést és egy Python-függvényt mutat be, amely a kötést használja. Ezután egy eseményt küld az egyéni témakörnek, a topicEndpointUrimegadott módon. A példa attól függ, hogy a v1 vagy v2 Python programozási modellt használja-e.

A függvény a function_app.py fájlban található:

import logging
import azure.functions as func
import datetime

app = func.FunctionApp()

@app.function_name(name="eventgrid_output")
@app.event_grid_trigger(arg_name="eventGridEvent")
@app.event_grid_output(
    arg_name="outputEvent",
    topic_endpoint_uri="MyEventGridTopicUriSetting",
    topic_key_setting="MyEventGridTopicKeySetting")
def eventgrid_output(eventGridEvent: func.EventGridEvent, 
         outputEvent: func.Out[func.EventGridOutputEvent]) -> None:

    logging.log("eventGridEvent: ", eventGridEvent)

    outputEvent.set(
        func.EventGridOutputEvent(
            id="test-id",
            data={"tag1": "value1", "tag2": "value2"},
            subject="test-subject",
            event_type="test-event-1",
            event_time=datetime.datetime.utcnow(),
            data_version="1.0"))

Attribútumok

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

Az attribútum konstruktora az egyéni témakör nevét tartalmazó alkalmazásbeállítás nevét és a témakörkulcsot tartalmazó alkalmazásbeállítás nevét veszi fel.

Az alábbi táblázat a paramétert ismerteti.EventGridOutputAttribute

Paraméter Leírás
TopicEndpointUri Az egyéni témakör URI-ját tartalmazó alkalmazásbeállítás neve, például MyTopicEndpointUri.
TopicKeySetting Az egyéni témakör hozzáférési kulcsát tartalmazó alkalmazásbeállítás neve.
Kapcsolat* A témakörvégpont URI-t tartalmazó beállítás közös előtagjának értéke. Az alkalmazásbeállítás elnevezési formátumával kapcsolatos további információkért lásd : Identitásalapú hitelesítés.

Jegyzetek

Java-osztályok esetén használja az EventGridAttribute attribútumot.

Az attribútum konstruktora az egyéni témakör nevét és a témakörkulcsot tartalmazó alkalmazásbeállítás nevét veszi fel. Ezekről a beállításokról további információt a Kimenet – konfiguráció című témakörben talál. Íme egy EventGridOutput példa attribútumra:

public class Function {
    @FunctionName("EventGridTriggerTest")
    public void run(@EventGridTrigger(name = "event") String content,
            @EventGridOutput(name = "outputEvent", topicEndpointUri = "MyEventGridTopicUriSetting", topicKeySetting = "MyEventGridTopicKeySetting") OutputBinding<String> outputEvent, final ExecutionContext context) {
            ...
    }
}

Konfiguráció

Az alábbi táblázat a metódusnak output.eventGrid() átadott objektumon options beállítható tulajdonságokat ismerteti.

Tulajdonság Leírás
topicEndpointUri Az egyéni témakör URI-ját tartalmazó alkalmazásbeállítás neve, például MyTopicEndpointUri.
topicKeySetting Az egyéni témakör hozzáférési kulcsát tartalmazó alkalmazásbeállítás neve.
Kapcsolat* A témakörvégpont URI-t tartalmazó beállítás közös előtagjának értéke. A tulajdonság beállításakor connection az és topicKeySetting a topicEndpointUri tulajdonságok nem állíthatók be. Az alkalmazásbeállítás elnevezési formátumával kapcsolatos további információkért lásd : Identitásalapú hitelesítés.

Konfiguráció

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

function.json tulajdonság Leírás
type A beállításnak a eventGridkövetkezőnek kell lennie: .
direction A beállításnak a outkövetkezőnek kell lennie: . Ez a paraméter automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
név Az eseményt jelképező függvénykódban használt változónév.
topicEndpointUri Az egyéni témakör URI-ját tartalmazó alkalmazásbeállítás neve, például MyTopicEndpointUri.
topicKeySetting Az egyéni témakör hozzáférési kulcsát tartalmazó alkalmazásbeállítás neve.
Kapcsolat* A témakörvégpont URI-t tartalmazó beállítás közös előtagjának értéke. Az alkalmazásbeállítás elnevezési formátumával kapcsolatos további információkért lásd : Identitásalapú hitelesítés.

*Az identitásalapú kapcsolatok támogatásához a bővítmény 3.3.x vagy újabb verziója szükséges.

Helyi fejlesztéskor adja hozzá az alkalmazásbeállításokat a gyűjtemény local.settings.json fájljáhozValues.

Fontos

Győződjön meg arról, hogy az egyéni témakör URI-ját TopicEndpointUri tartalmazó alkalmazásbeállítás nevére állítja be az értéket. Ne adja meg az egyéni témakör URI-ját közvetlenül ebben a tulajdonságban. Ugyanez érvényes a használat Connectionsorán is.

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

Használat

Az Event Grid kimeneti kötés á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 írjon, az Event Grid kimeneti kötése a következő típusokhoz köthet:

Típus Leírás
string Az esemény sztringként.
byte[] Az eseményüzenet bájtja.
JSON szerializálható típusok JSON-eseményt jelképező objektum. A Functions egy egyszerű régi CLR-objektum (POCO) típust próbál JSON-adatokká szerializálni.

Ha azt szeretné, hogy a függvény több eseményt írjon, az Event Grid kimeneti kötése a következő típusokhoz köthet:

Típus Leírás
T[] ahol T az egyik egyetlen eseménytípus Több eseményt tartalmazó tömb. Minden bejegyzés egy eseményt jelöl.

Egyéb kimeneti forgatókönyvek esetén közvetlenül hozzon létre és használjon típusokat az Azure.Messaging.EventGrid szolgáltatásból.

Egyéni üzenetek küldése metódusparaméter meghívásával, például out EventGridOutput paramNametöbb üzenet írásával ICollector<EventGridOutput>.

A kimeneti üzenet eléréséhez adja vissza az értéket közvetlenül vagy a használatával context.extraOutputs.set().

A kimeneti esemény eléréséhez használja a Push-OutputBinding parancsmagot, hogy eseményt küldjön az Event Grid kimeneti kötésének.

Az Event Grid-üzenetek függvényből való kimenetének két lehetősége van:

  • Visszatérési érték: Állítsa a tulajdonságot a name function.json értékre$return. Ezzel a konfigurációval a függvény visszatérési értéke Event Grid-üzenetként marad meg.
  • Imperatív: Adjon át egy értéket a Ki típusúként deklarált paraméter beállított metódusának. Az átadott set érték Event Grid-üzenetként marad meg.

Kapcsolatok

Az Event Grid kimeneti kötés használatakor kétféleképpen hitelesíthet egy Event Grid-témakört:

Hitelesítési módszer Leírás
Témakörkulcs használata A témakörkulcs használata című témakörben leírtak szerint állítsa be a tulajdonságokat és TopicKeySetting a TopicEndpointUri tulajdonságokat.
Identitás használata Állítsa a Connection tulajdonságot egy megosztott előtag nevére több alkalmazásbeállításhoz, és határozza meg az identitásalapú hitelesítést. Ez a módszer a bővítmény 3.3.x vagy újabb verziójának használatakor támogatott.

Témakörkulcs használata

Témakörkulcs konfigurálásához kövesse az alábbi lépéseket:

  1. Az Event Grid-témakör témaköréhez tartozó témakörkulcs beszerzéséhez kövesse a Hozzáférési kulcsok lekérése című témakör lépéseit.

  2. Az alkalmazásbeállításokban hozzon létre egy beállítást, amely meghatározza a témakörkulcs értékét. Használja a beállítás nevét a TopicKeySetting kötés tulajdonságához.

  3. Az alkalmazásbeállításokban hozzon létre egy beállítást, amely meghatározza a témakörvégpontot. Használja a beállítás nevét a TopicEndpointUri kötés tulajdonságához.

Identitásalapú hitelesítés

Ha a bővítmény 3.3.x vagy újabb verzióját használja, Microsoft Entra-identitással csatlakozhat egy Event Grid-témakörhöz, hogy elkerülje a témakörkulcsok beszerzését és használatát.

Létre kell hoznia egy alkalmazásbeállítást, amely visszaadja a témakörvégpont URI-jának értékét. A beállítás nevének egyesítenie kell egy egyedi közös előtagot (például myawesometopic) az értékkel __topicEndpointUri. Ezután ezt a közös előtagot kell használnia (ebben az esetben myawesometopic), amikor a tulajdonságot a Connection kötésben definiálja.

Ebben a módban a bővítményhez a következő tulajdonságok szükségesek:

Tulajdonság Környezeti változó sablonja Leírás Példaérték
Témakörvégpont URI-ja <CONNECTION_NAME_PREFIX>__topicEndpointUri A témakör végpontja. https://<topic-name>.centralus-1.eventgrid.azure.net/api/events

A kapcsolat testreszabásához további tulajdonságok használhatók. Tekintse meg az identitásalapú kapcsolatok gyakori tulajdonságait.

Feljegyzés

Ha Azure-alkalmazás konfigurációt vagy Key Vaultot használ a felügyelt identitásalapú kapcsolatok beállításainak megadásához, a beállításneveknek érvényes kulcselválasztót kell használniuk, például : a nevek helyes feloldása érdekében vagy / helyett__.

Például: <CONNECTION_NAME_PREFIX>:topicEndpointUri.

Az Azure Functions szolgáltatásban üzemeltetett identitásalapú kapcsolatok felügyelt identitást használnak. A rendszer alapértelmezés szerint a rendszer által hozzárendelt identitást használja, bár a felhasználó által hozzárendelt identitás megadható a credential tulajdonságokkal együtt clientID . Vegye figyelembe, hogy a felhasználó által hozzárendelt identitás erőforrás-azonosítóval való konfigurálása nem támogatott. Ha más környezetekben, például helyi fejlesztésben fut, a rendszer ehelyett a fejlesztői identitást használja, bár ez testre szabható. Lásd: Helyi fejlesztés identitásalapú kapcsolatokkal.

Engedély megadása az identitáshoz

Bármilyen identitást is használ, rendelkeznie kell a kívánt műveletek végrehajtásához szükséges engedélyekkel. A legtöbb Azure-szolgáltatás esetében ez azt jelenti, hogy egy szerepkört kell hozzárendelnie az Azure RBAC-ben beépített vagy egyéni szerepkörökkel, amelyek biztosítják ezeket az engedélyeket.

Fontos

A célszolgáltatás bizonyos engedélyeket közzétehet, amelyek nem minden környezethez szükségesek. Ahol lehetséges, tartsa be a minimális jogosultság elvét, és csak az identitáshoz szükséges jogosultságokat adja meg. Ha például az alkalmazásnak csak adatforrásból kell olvasnia, használjon olyan szerepkört, amely csak olvasási engedéllyel rendelkezik. Nem lenne helyénvaló olyan szerepkört hozzárendelni, amely lehetővé teszi az írást is a szolgáltatáshoz, mivel ez túlzott engedély lenne egy olvasási művelethez. Hasonlóképpen meg szeretné győződni arról, hogy a szerepkör-hozzárendelés csak az elolvasandó erőforrásokra terjed ki.

Létre kell hoznia egy szerepkör-hozzárendelést, amely futásidőben hozzáférést biztosít az Event Grid-témakörhöz. A tulajdonoshoz hasonló felügyeleti szerepkörök nem elegendőek. Az alábbi táblázat olyan beépített szerepköröket mutat be, amelyek az Event Hubs-bővítmény normál működésben való használatakor ajánlottak. Előfordulhat, hogy az alkalmazás további engedélyeket igényel az Ön által írt kód alapján.

Kötés típusa Példa beépített szerepkörökre
Kimeneti kötés EventGrid-közreműködő, EventGrid-adatküldő

Következő lépések