Azure Functions Event Grid triggerEvent Grid trigger for Azure Functions

Ez a cikk bemutatja, hogyan kezelheti Event Grid eseményeit Azure Functionsban.This article explains how to handle Event Grid events in Azure Functions.

Event Grid egy olyan Azure-szolgáltatás, amely HTTP-kéréseket küld, hogy értesítsea kiadói eseményekről.Event Grid is an Azure service that sends HTTP requests to notify you about events that happen in publishers. A közzétevő az eseményt kezdeményező szolgáltatás vagy erőforrás.A publisher is the service or resource that originates the event. Egy Azure Blob Storage-fiók például közzétevő, a blob feltöltése vagy törlése pedig egy esemény.For example, an Azure blob storage account is a publisher, and a blob upload or deletion is an event. Egyes Azure-szolgáltatások beépített támogatást biztosítanak az események Event Grid való közzétételéhez.Some Azure services have built-in support for publishing events to Event Grid.

Az eseménykezelők fogadják és dolgozzák fel az eseményeket.Event handlers receive and process events. A Azure Functions számos olyan Azure-szolgáltatás egyike, amelyek beépített támogatást biztosítanak a Event Grid események kezeléséhez.Azure Functions is one of several Azure services that have built-in support for handling Event Grid events. Ebből a cikkből megtudhatja, hogyan használhat egy Event Grid eseményindítót egy függvény meghívásához, amikor egy esemény érkezik a Event Gridból.In this article, you learn how to use an Event Grid trigger to invoke a function when an event is received from Event Grid.

Ha szeretné, használhat egy HTTP-triggert Event Grid események kezelésére; Lásd: http-trigger használata Event Grid triggerként a cikk későbbi részében.If you prefer, you can use an HTTP trigger to handle Event Grid Events; see Use an HTTP trigger as an Event Grid trigger later in this article. Jelenleg nem használhat Event Grid eseményindítót egy Azure Functions alkalmazáshoz, ha az esemény a CloudEvents-sémában kerül kézbesítésre.Currently, you can't use an Event Grid trigger for an Azure Functions app when the event is delivered in the CloudEvents schema. Ehelyett használjon HTTP-triggert.Instead, use an HTTP trigger.

Ez az információ az Azure Functions-fejlesztők számára.This is reference information for Azure Functions developers. Ha most ismerkedik az Azure Functions, indítsa el az alábbi forrásanyagokat:If you're new to Azure Functions, start with the following resources:

Csomagok – 2.x függvényekPackages - Functions 2.x

A Event Grid triggert a Microsoft. Azure. webjobs. Extensions. EventGrid NuGet csomagban, 2. x verzióban kell megadnia.The Event Grid trigger is provided in the Microsoft.Azure.WebJobs.Extensions.EventGrid NuGet package, version 2.x. A csomag forráskódja az Azure-functions-eventgrid-Extension GitHub-tárházban található.Source code for the package is in the azure-functions-eventgrid-extension GitHub repository.

Az alábbi táblázat bemutatja, hogyan lehet ezt a kötést támogatása hozzáadva minden fejlesztési környezetben.The following table tells how to add support for this binding in each development environment.

Fejlesztési környezetDevelopment environment A támogatás hozzáadásaTo add support in
Functions 2.xFunctions 2.x
Helyi fejlesztés – C# osztálytárLocal development - C# class library A csomag telepítéseInstall the package
Helyi fejlesztés – C# parancsfájl, JavaScript, F#, Java és Python nyelvenLocal development - C# script, JavaScript, F#, Java and Python A bővítmény regisztrálásaRegister the extension
A fejlesztői portálPortal development Telepítse a kimeneti kötés hozzáadása soránInstall when adding output binding

Megtudhatja, hogyan lehet frissíteni a létező kötés bővítmények a portálon való ismételt közzétételéhez a függvényalkalmazás projektjét nélkül, tekintse meg a a bővítmények frissítése.To learn how to update existing binding extensions in the portal without having to republish your function app project, see Update your extensions.

Csomagok – 1.x függvényekPackages - Functions 1.x

A Event Grid triggert a Microsoft. Azure. webjobs. Extensions. EventGrid NuGet csomagban, 1. x verzióban kell megadnia.The Event Grid trigger is provided in the Microsoft.Azure.WebJobs.Extensions.EventGrid NuGet package, version 1.x. A csomag forráskódja az Azure-functions-eventgrid-Extension GitHub-tárházban található.Source code for the package is in the azure-functions-eventgrid-extension GitHub repository.

Az alábbi táblázat bemutatja, hogyan lehet ezt a kötést támogatása hozzáadva minden fejlesztési környezetben.The following table tells how to add support for this binding in each development environment.

Fejlesztési környezetDevelopment environment A támogatás hozzáadásaTo add support in
Functions 1.xFunctions 1.x
Helyi fejlesztés – C# osztálytárLocal development - C# class library A csomag telepítéseInstall the package
Helyi fejlesztés – C# parancsfájl, JavaScript,F#Local development - C# script, JavaScript, F# AutomatikusAutomatic
A fejlesztői portálPortal development AutomatikusAutomatic

PéldaExample

Tekintse meg a Event Grid trigger nyelvspecifikus példáját:See the language-specific example for an Event Grid trigger:

A HTTP-triggerek példáját lásd: a http-trigger használata a cikk későbbi részében.For an HTTP trigger example, see How to use HTTP trigger later in this article.

C# (2.x)C# (2.x)

Az alábbi példa egy 2. x C# függvényt mutat be, amely a EventGridEventkövetkezőhöz kötődik:The following example shows a Functions 2.x C# function that binds to EventGridEvent:

using Microsoft.Azure.EventGrid.Models;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public static class EventGridTriggerCSharp
    {
        [FunctionName("EventGridTest")]
        public static void EventGridTest([EventGridTrigger]EventGridEvent eventGridEvent, ILogger log)
        {
            log.LogInformation(eventGridEvent.Data.ToString());
        }
    }
}

További információ: csomagok, attribútumok, konfigurációés használat.For more information, see Packages, Attributes, Configuration, and Usage.

C#(1. x verzió)C# (Version 1.x)

Az alábbi példa egy 1. x C# függvényt mutat be, amely a JObjectkövetkezőhöz kötődik:The following example shows a Functions 1.x C# function that binds to JObject:

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
using Microsoft.Azure.WebJobs.Host;
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));
        }
    }
}

C#parancsfájl – példaC# script example

Az alábbi példa egy trigger-kötést mutat be egy function. JSON fájlban, valamint egy olyan C# parancsfájl -függvényt, amely a kötést használja.The following example shows a trigger binding in a function.json file and a C# script function that uses the binding.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

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

C#parancsfájl (2. x verzió)C# script (Version 2.x)

Az itt található functions 2 C# . x szkript kódja a EventGridEventkövetkezőhöz kötődik:Here's Functions 2.x C# script code that binds to EventGridEvent:

#r "Microsoft.Azure.EventGrid"
using Microsoft.Azure.EventGrid.Models;
using Microsoft.Extensions.Logging;

public static void Run(EventGridEvent eventGridEvent, ILogger log)
{
    log.LogInformation(eventGridEvent.Data.ToString());
}

További információ: csomagok, attribútumok, konfigurációés használat.For more information, see Packages, Attributes, Configuration, and Usage.

C#parancsfájl (1. x verzió)C# script (Version 1.x)

Az itt található functions 1 C# . x szkript kódja a JObjectkövetkezőhöz kötődik:Here's Functions 1.x C# script code that binds to JObject:

#r "Newtonsoft.Json"

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

public static void Run(JObject eventGridEvent, TraceWriter log)
{
    log.Info(eventGridEvent.ToString(Formatting.Indented));
}

JavaScript-példaJavaScript example

Az alábbi példa egy trigger-kötést mutat be egy function. JSON fájlban, valamint egy JavaScript -függvényt, amely a kötést használja.The following example shows a trigger binding in a function.json file and a JavaScript function that uses the binding.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

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

A következő JavaScript-kódot:Here's the JavaScript code:

module.exports = 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));
    context.done();
};

Python-példaPython example

Az alábbi példa egy trigger-kötést mutat be egy function. JSON fájlban, valamint egy olyan Python -függvényt, amely a kötést használja.The following example shows a trigger binding in a function.json file and a Python function that uses the binding.

Itt van a kötési adatait a function.json fájlt:Here's the binding data in the function.json file:

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

Itt látható a Python-kód:Here's the Python code:

import logging
import azure.functions as func


def main(event: func.EventGridEvent):
    logging.info("Python Event Grid function processed a request.")
    logging.info("  Subject: %s", event.subject)
    logging.info("  Time: %s", event.event_time)
    logging.info("  Data: %s", event.get_json())

Trigger – Java-példákTrigger - Java examples

Ez a szakasz tartalmazza az alábbi példák:This section contains the following examples:

Az alábbi példákban egy function. JSON -fájlban és a kötést használó Java-függvények , valamint egy esemény kinyomtatásakor a rendszer eseményindító-kötést mutat be, majd először String a POJO fogadja az eseményt.The following examples show trigger binding in a function.json file and Java functions that use the binding and print out an event, first receiving the event as String and second as a POJO.

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

Event Grid trigger, string paraméter (Java)Event Grid trigger, String parameter (Java)

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

Event Grid trigger, POJO paraméter (Java)Event Grid trigger, POJO parameter (Java)

Ez a példa a következő POJO használja, amely egy Event Grid esemény legfelső szintű tulajdonságait jelöli:This example uses the following POJO, representing the top-level properties of an Event Grid event:

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-tartalma deszerializálható a EventSchema POJO a függvény általi használatra.Upon arrival, the event's JSON payload is de-serialized into the EventSchema POJO for use by the function. Ez lehetővé teszi, hogy a függvény objektumorientált módon hozzáférhessen az esemény tulajdonságaihoz.This allows the function to access the event's properties in an object-oriented way.

  @FunctionName("eventGridMonitor")
  public void logEvent(
    @EventGridTrigger(
      name = "event"
    ) 
    EventSchema event, 
    final ExecutionContext context) {
      // log 
      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 functions runtime library-ben használja EventGridTrigger a jegyzeteket azon paramétereknél, amelyek értéke a EventGrid származik.In the Java functions runtime library, use the EventGridTrigger annotation on parameters whose value would come from EventGrid. Az ezekkel a megjegyzésekkel rendelkező paraméterek a függvény futását okozzák, amikor egy esemény érkezik.Parameters with these annotations cause the function to run when an event arrives. Ez a jegyzet natív Java-típusokkal, Szerializálói vagy NULL értékű értékekkel használható a használatával Optional<T>.This annotation can be used with native Java types, POJOs, or nullable values using Optional<T>.

AttribútumokAttributes

Az C# osztályok könyvtáraibanhasználja a EventGridTrigger attribútumot.In C# class libraries, use the EventGridTrigger attribute.

Itt egy EventGridTrigger attribútum szerepel a metódus-aláírásban:Here's an EventGridTrigger attribute in a method signature:

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

Teljes példa: C# példa.For a complete example, see C# example.

KonfigurációConfiguration

A következő táblázat a function. JSON fájlban beállított kötési konfigurációs tulajdonságokat ismerteti.The following table explains the binding configuration properties that you set in the function.json file. Nincsenek beállítva konstruktor-paraméterek vagy tulajdonságok az EventGridTrigger attribútumban.There are no constructor parameters or properties to set in the EventGridTrigger attribute.

Function.JSON tulajdonságfunction.json property LeírásDescription
typetype Kötelező – a eventGridTriggerkövetkezőre kell beállítani:.Required - must be set to eventGridTrigger.
directiondirection Kötelező – a inkövetkezőre kell beállítani:.Required - must be set to in.
namename Kötelező – a függvény kódjában használt változó neve az esemény-adatfogadási paraméterhez.Required - the variable name used in function code for the parameter that receives the event data.

HasználatUsage

A (z) Azure Functions 1. x esetében C# a következő paramétereket használhatja a Event Grid triggerhez: F#For C# and F# functions in Azure Functions 1.x, you can use the following parameter types for the Event Grid trigger:

  • JObject
  • string

A C# ( F# z) Azure functions 2. x verzióban és a függvényekben a következő paraméter-típust is használhatja a Event Grid triggerhez:For C# and F# functions in Azure Functions 2.x, you also have the option to use the following parameter type for the Event Grid trigger:

  • Microsoft.Azure.EventGrid.Models.EventGridEvent-Az összes eseménytípus közös mezőinek tulajdonságait határozza meg.Microsoft.Azure.EventGrid.Models.EventGridEvent- Defines properties for the fields common to all event types.

Megjegyzés

Ha a functions v1-re próbál kötni Microsoft.Azure.WebJobs.Extensions.EventGrid.EventGridEvent, a fordító egy "elavult" üzenetet jelenít meg, és azt tanácsolja, hogy Microsoft.Azure.EventGrid.Models.EventGridEvent használja helyette.In Functions v1 if you try to bind to Microsoft.Azure.WebJobs.Extensions.EventGrid.EventGridEvent, the compiler will display a "deprecated" message and advise you to use Microsoft.Azure.EventGrid.Models.EventGridEvent instead. Az újabb típus használatához hivatkozzon a Microsoft. Azure. EventGrid NuGet-csomagra, és teljes mértékben EventGridEvent minősítse a típus nevét a következővel: Microsoft.Azure.EventGrid.Models.To use the newer type, reference the Microsoft.Azure.EventGrid NuGet package and fully qualify the EventGridEvent type name by prefixing it with Microsoft.Azure.EventGrid.Models. További információ a NuGet-csomagok C# parancsfájl-függvényekben való hivatkozásáról: NuGet-csomagok használataFor information about how to reference NuGet packages in a C# script function, see Using NuGet packages

JavaScript-függvények esetén a function. JSON name tulajdonság által megnevezett paraméter az Event objektumra mutató hivatkozást tartalmaz.For JavaScript functions, the parameter named by the function.json name property has a reference to the event object.

EseménysémaEvent schema

Egy Event Grid eseményhez tartozó adatmennyiség egy HTTP-kérelem törzsében JSON-objektumként érkezik.Data for an Event Grid event is received as a JSON object in the body of an HTTP request. A JSON a következő példához hasonlóan néz ki:The JSON looks similar to the following example:

[{
  "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 megjelenített példa egy elem tömbje.The example shown is an array of one element. Event Grid mindig egy tömböt küld, és több eseményt is küldhet a tömbben.Event Grid always sends an array and may send more than one event in the array. A futtatókörnyezet minden egyes tömb elemnél egyszer meghívja a függvényt.The runtime invokes your function once for each array element.

Az Event JSON-adattípusok legfelső szintű tulajdonságai megegyeznek az összes eseménytípus között, míg a data tulajdonság tartalma minden eseménytípus esetében egyedi.The top-level properties in the event JSON data are the same among all event types, while the contents of the data property are specific to each event type. A példa egy blob Storage-eseményre mutat.The example shown is for a blob storage event.

A Common és az Event-specifikus tulajdonságok magyarázatát az Event Grid dokumentációjában találja.For explanations of the common and event-specific properties, see Event properties in the Event Grid documentation.

A EventGridEvent típus csak a legfelső szintű tulajdonságokat definiálja, Data a tulajdonság JObjecta.The EventGridEvent type defines only the top-level properties; the Data property is a JObject.

Előfizetés létrehozásaCreate a subscription

Event Grid HTTP-kérelmek fogadásának megkezdéséhez hozzon létre egy Event Grid-előfizetést, amely megadja a függvényt meghívó végpont URL-címét.To start receiving Event Grid HTTP requests, create an Event Grid subscription that specifies the endpoint URL that invokes the function.

Azure PortalAzure portal

Az Event Grid triggerrel Azure Portalban fejlesztett függvények esetében válassza az Event Grid előfizetés hozzáadásalehetőséget.For functions that you develop in the Azure portal with the Event Grid trigger, select Add Event Grid subscription.

Előfizetés létrehozása a portálon

Ha ezt a hivatkozást választja, a portál megnyitja az esemény-előfizetés létrehozása lapot az előtöltött végpont URL-címével.When you select this link, the portal opens the Create Event Subscription page with the endpoint URL prefilled.

Végpont URL-címe előtöltve

Az előfizetések Azure Portal használatával történő létrehozásával kapcsolatos további információkért tekintse meg az egyéni esemény-Azure Portal létrehozása a Event Grid dokumentációjában.For more information about how to create subscriptions by using the Azure portal, see Create custom event - Azure portal in the Event Grid documentation.

Azure CLIAzure CLI

Ha Az Azure CLIhasználatával szeretne előfizetést létrehozni, használja az az eventgrid Event-előfizetés Create parancsot.To create a subscription by using the Azure CLI, use the az eventgrid event-subscription create command.

A parancshoz meg kell adni a végpont URL-címét, amely meghívja a függvényt.The command requires the endpoint URL that invokes the function. A következő példa a verzióra jellemző URL-mintát mutatja:The following example shows the version-specific URL pattern:

2-es verzió. x futtatókörnyezetVersion 2.x runtime

https://{functionappname}.azurewebsites.net/runtime/webhooks/eventgrid?functionName={functionname}&code={systemkey}

1. x verzió futtatókörnyezeteVersion 1.x runtime

https://{functionappname}.azurewebsites.net/admin/extensions/EventGridExtensionConfig?functionName={functionname}&code={systemkey}

A rendszerkulcs egy olyan engedélyezési kulcs, amely egy Event Grid trigger végponti URL-címében szerepelnie kell.The system key is an authorization key that has to be included in the endpoint URL for an Event Grid trigger. A következő szakasz ismerteti, hogyan kérheti le a rendszerkulcsot.The following section explains how to get the system key.

Az alábbi példa egy blob Storage-fiókra való előfizetést mutat be (a rendszerkulcs helyőrzője):Here's an example that subscribes to a blob storage account (with a placeholder for the system key):

2-es verzió. x futtatókörnyezetVersion 2.x runtime

az eventgrid resource event-subscription create -g myResourceGroup \
--provider-namespace Microsoft.Storage --resource-type storageAccounts \
--resource-name myblobstorage12345 --name myFuncSub  \
--included-event-types Microsoft.Storage.BlobCreated \
--subject-begins-with /blobServices/default/containers/images/blobs/ \
--endpoint https://mystoragetriggeredfunction.azurewebsites.net/runtime/webhooks/eventgrid?functionName=imageresizefunc&code=<key>

1. x verzió futtatókörnyezeteVersion 1.x runtime

az eventgrid resource event-subscription create -g myResourceGroup \
--provider-namespace Microsoft.Storage --resource-type storageAccounts \
--resource-name myblobstorage12345 --name myFuncSub  \
--included-event-types Microsoft.Storage.BlobCreated \
--subject-begins-with /blobServices/default/containers/images/blobs/ \
--endpoint https://mystoragetriggeredfunction.azurewebsites.net/admin/extensions/EventGridExtensionConfig?functionName=imageresizefunc&code=<key>

Az előfizetés létrehozásával kapcsolatos további információkért tekintse meg a blob Storage rövid útmutatóját vagy a többi Event Grid rövid útmutatót.For more information about how to create a subscription, see the blob storage quickstart or the other Event Grid quickstarts.

A rendszerkulcs beszerzéseGet the system key

A rendszerkulcs a következő API-val (HTTP GET) szerezhető be:You can get the system key by using the following API (HTTP GET):

2-es verzió. x futtatókörnyezetVersion 2.x runtime

http://{functionappname}.azurewebsites.net/admin/host/systemkeys/eventgrid_extension?code={masterkey}

1. x verzió futtatókörnyezeteVersion 1.x runtime

http://{functionappname}.azurewebsites.net/admin/host/systemkeys/eventgridextensionconfig_extension?code={masterkey}

Ez egy felügyeleti API, ezért a Function app főkulcsát igényli.This is an admin API, so it requires your function app master key. Ne tévesszük össze a rendszerkulcsot (egy Event Grid trigger függvény meghívásához) a főkulccsal (a Function alkalmazás felügyeleti feladatainak végrehajtásához).Don't confuse the system key (for invoking an Event Grid trigger function) with the master key (for performing administrative tasks on the function app). Amikor előfizet egy Event Grid témakörre, ügyeljen arra, hogy a rendszerkulcsot használja.When you subscribe to an Event Grid topic, be sure to use the system key.

Íme egy példa a rendszerkulcsot biztosító válaszra:Here's an example of the response that provides the system key:

{
  "name": "eventgridextensionconfig_extension",
  "value": "{the system key for the function}",
  "links": [
    {
      "rel": "self",
      "href": "{the URL for the function, without the system key}"
    }
  ]
}

A Function alkalmazás főkulcsát a portál Function app Settings lapján szerezheti be.You can get the master key for your function app from the Function app settings tab in the portal.

Fontos

A főkulcs rendszergazdai hozzáférést biztosít a Function alkalmazáshoz.The master key provides administrator access to your function app. Ne ossza meg ezt a kulcsot harmadik felekkel, vagy terjessze azt natív ügyfélalkalmazásokba.Don't share this key with third parties or distribute it in native client applications.

További információ: engedélyezési kulcsok a http-trigger dokumentációjában.For more information, see Authorization keys in the HTTP trigger reference article.

Azt is megteheti, hogy HTTP-PUT-t küld a kulcs értékének megadásához.Alternatively, you can send an HTTP PUT to specify the key value yourself.

Helyi tesztelés a megjelenítői webalkalmazássalLocal testing with viewer web app

Event Grid-trigger helyi teszteléséhez be kell szereznie Event Grid HTTP-kéréseket a felhőből a helyi gépre.To test an Event Grid trigger locally, you have to get Event Grid HTTP requests delivered from their origin in the cloud to your local machine. Ennek egyik módja a kérelmek online rögzítésének és manuális újraküldése a helyi gépen:One way to do that is by capturing requests online and manually resending them on your local machine:

  1. Hozzon létre egy megjelenítői webalkalmazást, amely rögzíti az események üzeneteit.Create a viewer web app that captures event messages.
  2. Hozzon létre egy Event Grid -előfizetést, amely eseményeket küld a megjelenítői alkalmazásnak.Create an Event Grid subscription that sends events to the viewer app.
  3. Kérelem létrehozása és a kérelem törzsének másolása a megjelenítői alkalmazásból.Generate a request and copy the request body from the viewer app.
  4. Manuálisan tegye közzé a kérést a Event Grid trigger függvény localhost URL-címére.Manually post the request to the localhost URL of your Event Grid trigger function.

Ha végzett a teszteléssel, a végpont frissítésével ugyanazt az előfizetést használhatja éles környezethez.When you're done testing, you can use the same subscription for production by updating the endpoint. Használja az az eventgrid Event-előfizetés Update Azure CLI parancsot.Use the az eventgrid event-subscription update Azure CLI command.

Megjelenítői Webalkalmazás létrehozásaCreate a viewer web app

Az üzenetek rögzítésének egyszerűbbé tétele érdekében üzembe helyezhet egy előre elkészített webalkalmazást, amely megjeleníti az esemény üzeneteit.To simplify capturing event messages, you can deploy a pre-built web app that displays the event messages. Az üzembe helyezett megoldás egy App Service-csomagot, egy App Service-webalkalmazást és egy, a GitHubról származó forráskódot tartalmaz.The deployed solution includes an App Service plan, an App Service web app, and source code from GitHub.

A megoldásnak az előfizetésébe való telepítéséhez válassza az Üzembe helyezés az Azure-ban lehetőséget.Select Deploy to Azure to deploy the solution to your subscription. Az Azure Portalon adjon meg értékeket a paraméterekhez.In the Azure portal, provide values for the parameters.

Az üzembe helyezés befejezése eltarthat néhány percig.The deployment may take a few minutes to complete. A sikeres üzembe helyezést követően tekintse meg a webalkalmazást, hogy meggyőződjön annak működéséről.After the deployment has succeeded, view your web app to make sure it's running. Egy webböngészőben navigáljon a következő helyre: https://<your-site-name>.azurewebsites.net.In a web browser, navigate to: https://<your-site-name>.azurewebsites.net

A hely látható, de még nem lett közzétéve esemény.You see the site but no events have been posted to it yet.

Új hely megtekintése

Event Grid-előfizetés létrehozásaCreate an Event Grid subscription

Hozzon létre egy Event Grid-előfizetést a tesztelni kívánt típushoz, és adja meg a webalkalmazás URL-címét az eseményekről szóló értesítés végpontja.Create an Event Grid subscription of the type you want to test, and give it the URL from your web app as the endpoint for event notification. A webalkalmazás végpontjának az /api/updates/ utótagot kell tartalmaznia.The endpoint for your web app must include the suffix /api/updates/. Tehát a teljes URL-címhttps://<your-site-name>.azurewebsites.net/api/updatesSo, the full URL is https://<your-site-name>.azurewebsites.net/api/updates

További információ az előfizetések létrehozásáról a Azure Portal használatával: Egyéni Event-Azure Portal létrehozása a Event Grid dokumentációjában.For information about how to create subscriptions by using the Azure portal, see Create custom event - Azure portal in the Event Grid documentation.

Kérelem létrehozásaGenerate a request

Indítson el egy eseményt, amely a webalkalmazás-végpontra HTTP-forgalmat fog előállítani.Trigger an event that will generate HTTP traffic to your web app endpoint. Ha például létrehozta a blob Storage-előfizetést, feltölt vagy töröl egy blobot.For example, if you created a blob storage subscription, upload or delete a blob. Ha egy kérelem megjelenik a webalkalmazásban, másolja a kérelem törzsét.When a request shows up in your web app, copy the request body.

A rendszer először az előfizetés-ellenőrzési kérelmet kapja meg; hagyja figyelmen kívül az érvényesítési kérelmeket, és másolja az eseményre vonatkozó kérelmet.The subscription validation request will be received first; ignore any validation requests, and copy the event request.

Kérelem törzsének másolása a webalkalmazásból

A kérelem manuális közzétételeManually post the request

Futtassa helyileg a Event Grid függvényt.Run your Event Grid function locally.

HTTP POST-kérelem létrehozásához használjon olyan eszközt, mint például a Poster vagy a curl :Use a tool such as Postman or curl to create an HTTP POST request:

  • Adja meg Content-Type: application/json a fejlécet.Set a Content-Type: application/json header.
  • Adja meg aeg-event-type: Notification a fejlécet.Set an aeg-event-type: Notification header.
  • Illessze be a RequestBin a kérelem törzsébe.Paste the RequestBin data into the request body.
  • Tegye közzé a Event Grid trigger függvény URL-címét.Post to the URL of your Event Grid trigger function.
    • A 2. x esetében használja a következő mintát:For 2.x use the following pattern:

      http://localhost:7071/runtime/webhooks/eventgrid?functionName={FUNCTION_NAME}
      
    • 1. x esetén használja a következőt:For 1.x use:

      http://localhost:7071/admin/extensions/EventGridExtensionConfig?functionName={FUNCTION_NAME}
      

A functionName paraméternek az FunctionName attribútumban megadott névnek kell lennie.The functionName parameter must be the name specified in the FunctionName attribute.

A következő Képernyőképek a Poster fejléceit és a kérelem törzsét mutatják be:The following screenshots show the headers and request body in Postman:

Fejlécek a Poster-ban

Kérelem törzse a Poster-ban

A Event Grid trigger függvény végrehajtja és megjeleníti a következő példához hasonló naplókat:The Event Grid trigger function executes and shows logs similar to the following example:

Minta Event Grid trigger-függvények naplói

Helyi tesztelés a ngrokLocal testing with ngrok

Egy Event Grid trigger helyi tesztelésének másik módja az Internet és a fejlesztői számítógép közötti HTTP-kapcsolat automatizálása.Another way to test an Event Grid trigger locally is to automate the HTTP connection between the Internet and your development computer. Ezt egy olyan eszközzel teheti meg, mint a ngrok:You can do that with a tool like ngrok:

  1. Hozzon létre egy ngrok-végpontot.Create an ngrok endpoint.
  2. Futtassa a Event Grid trigger függvényt.Run the Event Grid trigger function.
  3. Hozzon létre egy Event Grid -előfizetést, amely eseményeket küld a ngrok-végpontnak.Create an Event Grid subscription that sends events to the ngrok endpoint.
  4. Esemény elindítása.Trigger an event.

Ha végzett a teszteléssel, a végpont frissítésével ugyanazt az előfizetést használhatja éles környezethez.When you're done testing, you can use the same subscription for production by updating the endpoint. Használja az az eventgrid Event-előfizetés Update Azure CLI parancsot.Use the az eventgrid event-subscription update Azure CLI command.

Ngrok-végpont létrehozásaCreate an ngrok endpoint

Töltse le a ngrok. exe fájlt a ngrok-ből, és futtassa a parancsot a következő paranccsal:Download ngrok.exe from ngrok, and run with the following command:

ngrok http -host-header=localhost 7071

A-Host-header paraméterre azért van szükség, mert a functions Runtime a localhost-on futtatott gazdagépről érkező kéréseket vár.The -host-header parameter is needed because the functions runtime expects requests from localhost when it runs on localhost. a 7071 az alapértelmezett portszám, ha a futtatókörnyezet helyileg fut.7071 is the default port number when the runtime runs locally.

A parancs a következőhöz hasonló kimenetet hoz létre:The command creates output like the following:

Session Status                online
Version                       2.2.8
Region                        United States (us)
Web Interface                 http://127.0.0.1:4040
Forwarding                    http://263db807.ngrok.io -> localhost:7071
Forwarding                    https://263db807.ngrok.io -> localhost:7071

Connections                   ttl     opn     rt1     rt5     p50     p90
                              0       0       0.00    0.00    0.00    0.00

A https://{subdomain}.ngrok.io Event Grid-előfizetés URL-címét fogja használni.You'll use the https://{subdomain}.ngrok.io URL for your Event Grid subscription.

A Event Grid trigger függvény futtatásaRun the Event Grid trigger function

A ngrok URL-cím nem kap speciális kezelést Event Grid alapján, így a függvénynek helyileg kell futnia az előfizetés létrehozásakor.The ngrok URL doesn't get special handling by Event Grid, so your function must be running locally when the subscription is created. Ha nem, az érvényesítési válasz nem lesz elküldve, és az előfizetés létrehozása sikertelen lesz.If it isn't, the validation response doesn't get sent and the subscription creation fails.

Előfizetés létrehozásaCreate a subscription

Hozzon létre egy Event Grid-előfizetést a tesztelni kívánt típushoz, és adja meg a ngrok-végpontot.Create an Event Grid subscription of the type you want to test, and give it your ngrok endpoint.

Használja ezt a végponti mintát a 2. x függvényhez:Use this endpoint pattern for Functions 2.x:

https://{SUBDOMAIN}.ngrok.io/runtime/webhooks/eventgrid?functionName={FUNCTION_NAME}

Használja ezt a végponti mintát az 1. x függvényeknél:Use this endpoint pattern for Functions 1.x:

https://{SUBDOMAIN}.ngrok.io/admin/extensions/EventGridExtensionConfig?functionName={FUNCTION_NAME}

A {FUNCTION_NAME} paraméternek az FunctionName attribútumban megadott névnek kell lennie.The {FUNCTION_NAME} parameter must be the name specified in the FunctionName attribute.

Íme egy példa az Azure CLI használatával:Here's an example using the Azure CLI:

az eventgrid event-subscription create --resource-id /subscriptions/aeb4b7cb-b7cb-b7cb-b7cb-b7cbb6607f30/resourceGroups/eg0122/providers/Microsoft.Storage/storageAccounts/egblobstor0122 --name egblobsub0126 --endpoint https://263db807.ngrok.io/runtime/webhooks/eventgrid?functionName=EventGridTrigger

További információ az előfizetés létrehozásáról: előfizetés létrehozása a cikk korábbi részében.For information about how to create a subscription, see Create a subscription earlier in this article.

Események aktiválásaTrigger an event

Indítson el egy eseményt, amely a ngrok-végpontra HTTP-forgalmat fog előállítani.Trigger an event that will generate HTTP traffic to your ngrok endpoint. Ha például létrehozta a blob Storage-előfizetést, feltölt vagy töröl egy blobot.For example, if you created a blob storage subscription, upload or delete a blob.

A Event Grid trigger függvény végrehajtja és megjeleníti a következő példához hasonló naplókat:The Event Grid trigger function executes and shows logs similar to the following example:

Minta Event Grid trigger-függvények naplói

HTTP-trigger használata Event Grid triggerkéntUse an HTTP trigger as an Event Grid trigger

Event Grid események fogadása HTTP-kérésként történik, így az eseményeket egy Event Grid trigger helyett HTTP-trigger használatával kezelheti.Event Grid events are received as HTTP requests, so you can handle events by using an HTTP trigger instead of an Event Grid trigger. Ennek egyik lehetséges oka, hogy jobban kézben tarthatja a függvényt meghívó végponti URL-címet.One possible reason for doing that is to get more control over the endpoint URL that invokes the function. Egy másik ok az, amikor eseményeket kell fogadnia a CloudEvents sémában.Another reason is when you need to receive events in the CloudEvents schema. A Event Grid trigger jelenleg nem támogatja a CloudEvents sémát.Currently, the Event Grid trigger doesn't support the CloudEvents schema. Az ebben a szakaszban szereplő példák a Event Grid séma és a CloudEvents séma megoldásait mutatják be.The examples in this section show solutions for both Event Grid schema and CloudEvents schema.

Ha HTTP-triggert használ, kódot kell írnia ahhoz, hogy mit tesz a Event Grid trigger automatikusan:If you use an HTTP trigger, you have to write code for what the Event Grid trigger does automatically:

További információ a függvény helyi meghívásához vagy az Azure-ban való futtatásához használt URL-címről: http-trigger kötési útmutatója – dokumentációFor information about the URL to use for invoking the function locally or when it runs in Azure, see the HTTP trigger binding reference documentation

Event Grid-sémaEvent Grid schema

A következő mintakód C# egy http-triggerhez szimulálja Event Grid trigger viselkedését.The following sample C# code for an HTTP trigger simulates Event Grid trigger behavior. Ezt a példát a Event Grid sémában szállított eseményekhez használhatja.Use this example for events delivered in the Event Grid schema.

[FunctionName("HttpTrigger")]
public static async Task<HttpResponseMessage> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post")]HttpRequestMessage req,
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    var messages = await req.Content.ReadAsAsync<JArray>();

    // If the request is for subscription validation, send back the validation code.
    if (messages.Count > 0 && string.Equals((string)messages[0]["eventType"],
        "Microsoft.EventGrid.SubscriptionValidationEvent",
        System.StringComparison.OrdinalIgnoreCase))
    {
        log.LogInformation("Validate request received");
        return req.CreateResponse<object>(new
        {
            validationResponse = messages[0]["data"]["validationCode"]
        });
    }

    // The request is not for subscription validation, so it's for one or more events.
    foreach (JObject message in messages)
    {
        // Handle one event.
        EventGridEvent eventGridEvent = message.ToObject<EventGridEvent>();
        log.LogInformation($"Subject: {eventGridEvent.Subject}");
        log.LogInformation($"Time: {eventGridEvent.EventTime}");
        log.LogInformation($"Event data: {eventGridEvent.Data.ToString()}");
    }

    return req.CreateResponse(HttpStatusCode.OK);
}

A következő minta JavaScript-kód a HTTP-triggerekhez szimulálja Event Grid trigger viselkedését.The following sample JavaScript code for an HTTP trigger simulates Event Grid trigger behavior. Ezt a példát a Event Grid sémában szállított eseményekhez használhatja.Use this example for events delivered in the Event Grid schema.

module.exports = function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    var messages = req.body;
    // If the request is for subscription validation, send back the validation code.
    if (messages.length > 0 && messages[0].eventType == "Microsoft.EventGrid.SubscriptionValidationEvent") {
        context.log('Validate request received');
        var code = messages[0].data.validationCode;
        context.res = { status: 200, body: { "ValidationResponse": code } };
    }
    else {
        // The request is not for subscription validation, so it's for one or more events.
        // Event Grid schema delivers events in an array.
        for (var i = 0; i < messages.length; i++) {
            // Handle one event.
            var message = messages[i];
            context.log('Subject: ' + message.subject);
            context.log('Time: ' + message.eventTime);
            context.log('Data: ' + JSON.stringify(message.data));
        }
    }
    context.done();
};

Az eseménykezelő kód a messages tömbön belülről megy át a hurokban.Your event-handling code goes inside the loop through the messages array.

CloudEvents sémaCloudEvents schema

A következő mintakód C# egy http-triggerhez szimulálja Event Grid trigger viselkedését.The following sample C# code for an HTTP trigger simulates Event Grid trigger behavior. Ezt a példát a CloudEvents sémában elküldött eseményekhez használhatja.Use this example for events delivered in the CloudEvents schema.

[FunctionName("HttpTrigger")]
public static async Task<HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]HttpRequestMessage req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    var requestmessage = await req.Content.ReadAsStringAsync();
    var message = JToken.Parse(requestmessage);

    if (message.Type == JTokenType.Array)
    {
        // If the request is for subscription validation, send back the validation code.
        if (string.Equals((string)message[0]["eventType"],
        "Microsoft.EventGrid.SubscriptionValidationEvent",
        System.StringComparison.OrdinalIgnoreCase))
        {
            log.LogInformation("Validate request received");
            return req.CreateResponse<object>(new
            {
                validationResponse = message[0]["data"]["validationCode"]
            });
        }
    }
    else
    {
        // The request is not for subscription validation, so it's for an event.
        // CloudEvents schema delivers one event at a time.
        log.LogInformation($"Source: {message["source"]}");
        log.LogInformation($"Time: {message["eventTime"]}");
        log.LogInformation($"Event data: {message["data"].ToString()}");
    }

    return req.CreateResponse(HttpStatusCode.OK);
}

A következő minta JavaScript-kód a HTTP-triggerekhez szimulálja Event Grid trigger viselkedését.The following sample JavaScript code for an HTTP trigger simulates Event Grid trigger behavior. Ezt a példát a CloudEvents sémában elküldött eseményekhez használhatja.Use this example for events delivered in the CloudEvents schema.

module.exports = function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    var message = req.body;
    // If the request is for subscription validation, send back the validation code.
    if (message.length > 0 && message[0].eventType == "Microsoft.EventGrid.SubscriptionValidationEvent") {
        context.log('Validate request received');
        var code = message[0].data.validationCode;
        context.res = { status: 200, body: { "ValidationResponse": code } };
    }
    else {
        // The request is not for subscription validation, so it's for an event.
        // CloudEvents schema delivers one event at a time.
        var event = JSON.parse(message);
        context.log('Source: ' + event.source);
        context.log('Time: ' + event.eventTime);
        context.log('Data: ' + JSON.stringify(event.data));
    }
    context.done();
};

További lépésekNext steps