Gatilho de Grade de Eventos do Azure para o Azure Functions

O modelo de programação Python v2 permite definir ligações usando decoradores diretamente em seu código de função Python. Para obter mais informações, consulte o guia do desenvolvedor do Python.

O modelo de programação Python v1 requer que você defina ligações em um arquivo function.json separado na pasta de funções. Para obter mais informações, consulte o guia do desenvolvedor do Python.

Ao executar sua função C# em um processo de trabalho isolado, você precisa definir um tipo personalizado para propriedades de evento. O exemplo a seguir define uma MyEventType classe.

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

O exemplo a seguir mostra como o tipo personalizado é usado no gatilho e em uma associação de saída de Grade de Eventos:

    [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
{

O exemplo a seguir mostra uma função Functions versão 4.x que usa um CloudEvent parâmetro de ligação:

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

O exemplo a seguir mostra uma função Functions versão 4.x que usa um EventGridEvent parâmetro de ligação:

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

O exemplo a seguir mostra uma função que usa um JObject parâmetro de ligação:

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

O exemplo a seguir mostra uma função TypeScript de gatilho de grade de eventos.

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

Os exemplos de TypeScript não estão documentados para o modelo v3.

O exemplo a seguir mostra uma função JavaScript de gatilho de grade de eventos.

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

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

O exemplo a seguir mostra uma ligação de gatilho em um arquivo function.json e uma função JavaScript que usa a ligação.

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código JavaScript:

module.exports = async function (context, eventGridEvent) {
    context.log("JavaScript Event Grid function processed a request.");
    context.log("Subject: " + eventGridEvent.subject);
    context.log("Time: " + eventGridEvent.eventTime);
    context.log("Data: " + JSON.stringify(eventGridEvent.data));
};

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)

Aqui estão os dados de ligação no arquivo function.json :

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

Aqui está o código Python:

import json
import logging

import azure.functions as func

def main(event: func.EventGridEvent):

    result = json.dumps({
        'id': event.id,
        'data': event.get_json(),
        'topic': event.topic,
        'subject': event.subject,
        'event_type': event.event_type,
    })

    logging.info('Python EventGrid trigger processed an event: %s', result)

Aqui está um EventGridTrigger atributo em uma assinatura de método:

public static MyEventType Run([EventGridTrigger] MyEventType input, FunctionContext context)
{
    var logger = context.GetLogger(nameof(EventGridFunction));
    logger.LogInformation(input.Data?.ToString());

Aqui está um EventGridTrigger atributo em uma assinatura de método:

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

O options objeto passado para o método atualmente não suporta nenhuma propriedade para o app.eventGrid() modelo v4.

A tabela a seguir explica as propriedades de configuração de associação definidas no arquivo function.json .

As funções da biblioteca de classes C# em processo suportam os seguintes tipos:

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

As funções da biblioteca de classes C# em processo suportam os seguintes tipos:

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

As funções da biblioteca de classes C# em processo suportam os seguintes tipos:

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

Quando você deseja que a função processe um único evento, o gatilho Grade de Eventos pode se vincular aos seguintes tipos:

Quando você deseja que a função processe um lote de eventos, o gatilho Grade de Eventos pode se vincular aos seguintes tipos:

1 Para usar esses tipos, você precisa fazer referência a Microsoft.Azure.Functions.Worker.Extensions.EventGrid 3.3.0 ou posterior e às dependências comuns para associações de tipo SDK.

Requer que você defina um tipo personalizado ou use uma cadeia de caracteres. Consulte a seção Exemplo para obter exemplos de como usar um tipo de parâmetro personalizado.

O Functions versão 1.x não suporta o processo de trabalho isolado.