Associação de saída dos Hubs de Eventos do Azure para Azure Functions

O modelo de programação v2 do Python permite que você defina associações usando decoradores diretamente no código de função do Python. Para saber mais, confira o Guia do desenvolvedor do Python.

O modelo de programação v1 do Python requer que você defina as associações em um arquivo function.json separado na pasta de funções. Para saber mais, confira o Guia do desenvolvedor do Python.

O exemplo a seguir mostra uma função C# que grava uma cadeia de caracteres de mensagem em um hub de eventos, usando o valor retornado do método como a saída:

[Function(nameof(EventHubFunction))]
[FixedDelayRetry(5, "00:00:10")]
[EventHubOutput("dest", Connection = "EventHubConnection")]
public string EventHubFunction(
    [EventHubTrigger("src", Connection = "EventHubConnection")] string[] input,
    FunctionContext context)
{
    _logger.LogInformation("First Event Hubs triggered message: {msg}", input[0]);

    var message = $"Output message created at {DateTime.Now}";
    return message;
}

O exemplo a seguir mostra uma função C# que grava uma mensagem em um hub de eventos, usando o valor retornado do método como a saída:

[FunctionName("EventHubOutput")]
[return: EventHub("outputEventHubMessage", Connection = "EventHubConnectionAppSetting")]
public static string Run([TimerTrigger("0 */5 * * * *")] TimerInfo myTimer, ILogger log)
{
    log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
    return $"{DateTime.Now}";
}

O exemplo a seguir mostra como usar a interface IAsyncCollector para enviar um lote de mensagens. Esse cenário será comum quando você estiver processando mensagens provenientes de um hub de eventos e enviando o resultado para outro hub de eventos.

[FunctionName("EH2EH")]
public static async Task Run(
    [EventHubTrigger("source", Connection = "EventHubConnectionAppSetting")] EventData[] events,
    [EventHub("dest", Connection = "EventHubConnectionAppSetting")]IAsyncCollector<EventData> outputEvents,
    ILogger log)
{
    foreach (EventData eventData in events)
    {
        // Do some processing:
        string newEventBody = DoSomething(eventData);

        // Queue the message to be sent in the background by adding it to the collector.
        // If only the event is passed, an Event Hubs partition to be assigned via
        // round-robin for each batch.
        await outputEvents.AddAsync(new EventData(newEventBody));

        // If your scenario requires that certain events are grouped together in an
        // Event Hubs partition, you can specify a partition key.  Events added with 
        // the same key will always be assigned to the same partition.        
        await outputEvents.AddAsync(new EventData(newEventBody), "sample-key");
    }
}

O exemplo a seguir mostra uma função TypeScript disparada pelo temporizador que envia uma única mensagem para um hub de eventos:

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

export async function timerTrigger1(myTimer: Timer, context: InvocationContext): Promise<string> {
    const timeStamp = new Date().toISOString();
    return `Message created at: ${timeStamp}`;
}

app.timer('timerTrigger1', {
    schedule: '0 */5 * * * *',
    return: output.eventHub({
        eventHubName: 'myeventhub',
        connection: 'MyEventHubSendAppSetting',
    }),
    handler: timerTrigger1,
});

Para gerar várias mensagens, retorne uma matriz em vez de um único objeto. Por exemplo:

const timeStamp = new Date().toISOString();
const message = `Message created at: ${timeStamp}`;
return [`1: ${message}`, `2: ${message}`];

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

O exemplo a seguir mostra uma função JavaScript disparada pelo temporizador que envia uma única mensagem para um hub de eventos:

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

const eventHubOutput = output.eventHub({
    eventHubName: 'myeventhub',
    connection: 'MyEventHubSendAppSetting',
});

app.timer('timerTrigger1', {
    schedule: '0 */5 * * * *',
    return: eventHubOutput,
    handler: (myTimer, context) => {
        const timeStamp = new Date().toISOString();
        return `Message created at: ${timeStamp}`;
    },
});

Para gerar várias mensagens, retorne uma matriz em vez de um único objeto. Por exemplo:

const timeStamp = new Date().toISOString();
const message = `Message created at: ${timeStamp}`;
return [`1: ${message}`, `2: ${message}`];

O exemplo a seguir mostra uma associação de gatilho de hub de eventos em um arquivo function.json e uma função que usa a associação. A função grava uma mensagem de saída em um hub de eventos.

O exemplo a seguir mostra os dados de vinculação dos Hubs de Eventos no arquivo function.json, que é diferente para a versão 1.x do runtime do Functions em comparação com as versões posteriores.

{
    "type": "eventHub",
    "name": "outputEventHubMessage",
    "eventHubName": "myeventhub",
    "connection": "MyEventHubSendAppSetting",
    "direction": "out"
}

Este é o código JavaScript que envia uma mensagem única:

module.exports = function (context, myTimer) {
    var timeStamp = new Date().toISOString();
    context.log('Message created at: ', timeStamp);   
    context.bindings.outputEventHubMessage = "Message created at: " + timeStamp;
    context.done();
};

Este é o código JavaScript que envia várias mensagens:

module.exports = function(context) {
    var timeStamp = new Date().toISOString();
    var message = 'Message created at: ' + timeStamp;

    context.bindings.outputEventHubMessage = [];

    context.bindings.outputEventHubMessage.push("1 " + message);
    context.bindings.outputEventHubMessage.push("2 " + message);
    context.done();
};

import logging
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="eventhub_output")
@app.route(route="eventhub_output")
@app.event_hub_output(arg_name="event",
                      event_hub_name="<EVENT_HUB_NAME>",
                      connection="<CONNECTION_SETTING>")
def eventhub_output(req: func.HttpRequest, event: func.Out[str]):
    body = req.get_body()
    if body is not None:
        event.set(body.decode('utf-8'))
    else:    
        logging.info('req body is none')
    return 'ok'

Aqui está o código Python que envia várias mensagens:

import logging
import azure.functions as func
from typing import List

app = func.FunctionApp()

@app.function_name(name="eventhub_output")
@app.route(route="eventhub_output")
@app.event_hub_output(arg_name="event",
                      event_hub_name="<EVENT_HUB_NAME>",
                      connection="<CONNECTION_SETTING>")

def eventhub_output(req: func.HttpRequest, event: func.Out[List[str]]) -> func.HttpResponse:
    my_messages=["message1", "message2","message3"]
    event.set(my_messages)
    return func.HttpResponse(f"Messages sent")

Os exemplos a seguir mostram dados de associação de Hubs de eventos no function.json arquivo.

{
    "type": "eventHub",
    "name": "$return",
    "eventHubName": "myeventhub",
    "connection": "MyEventHubSendAppSetting",
    "direction": "out"
}

Este é o código Python que envia uma mensagem única:

import datetime
import logging
import azure.functions as func


def main(timer: func.TimerRequest) -> str:
    timestamp = datetime.datetime.utcnow()
    logging.info('Message created at: %s', timestamp)
    return 'Message created at: {}'.format(timestamp)

Aqui está o código Python que envia várias mensagens:

import logging
from typing import List
import azure.functions as func


def main(req: func.HttpRequest, messages:func.Out[List[str]]) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')
    messages.set([{"message1"}, {"message2"}])
    return func.HttpResponse(f"Messages sent")

Use o [EventHubOutputAttribute] para definir uma associação de saída para um hub de eventos, que permite as propriedades a seguir.

Use o EventHubAttribute para definir uma associação de saída para um hub de eventos, que permite as propriedades a seguir.

A tabela a seguir explica as propriedades que você pode definir no objeto options transmitido para o método output.eventHub().

A tabela a seguir explica as propriedades de configuração de associação que você define no arquivo function.json.

As funções da biblioteca de classes C# em processo são compatíveis com os seguintes tipos:

• Azure.Messaging.EventHubs.EventData
• String
• Matriz de bytes
• Objeto CRL básico (POCO)

Essa versão do EventData remove o suporte do tipo Body herdado em favor do EventBody.

Envie mensagens usando um parâmetro de método, como out string paramName. Para gravar várias mensagens, você pode usar ICollector<EventData> ou IAsyncCollector<EventData> no lugar de out string. As chaves de partição só podem ser usadas com IAsyncCollector<EventData>.

As funções da biblioteca de classes C# em processo são compatíveis com os seguintes tipos:

• Microsoft.Azure.EventHubs.EventData
• String
• Matriz de bytes
• Objeto CRL básicoo (POCO)

Envie mensagens usando um parâmetro de método, como out string paramName. Para gravar várias mensagens, você pode usar ICollector<string> ou IAsyncCollector<string> no lugar de out string.

Quando você quiser que a função escreva um único evento, a associação de saída dos Hubs de Eventos pode ser associada aos seguintes tipos:

Quando você quiser que a função escreva vários eventos, a associação de saída dos Hubs de Eventos pode ser associada aos seguintes tipos:

Para outros cenários de saída, crie e use um EventHubProducerClient com outros tipos diretamente de Azure.Messaging.EventHubs . Consulte Registrar clientes do Azure para obter um exemplo de como usar a injeção de dependência para criar um tipo de cliente do SDK do Azure.

Exige que você defina um tipo personalizado ou use uma cadeia de caracteres. Opções adicionais estão disponíveis para a Extensão v5.x+.

Acesse a mensagem de saída retornando o valor diretamente ou usando context.extraOutputs.set().

Acesse o evento de saída usando context.bindings.<name>, em que <name> é o valor especificado na propriedade name de context.bindings.<name>.