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

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

O modelo de programação Python v1 exige que você defina associações em um arquivo function.json separado na pasta de funções. Para obter mais informações, consulte o guia do desenvolvedor 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á Python código 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"
}

Aqui está Python código que envia uma única mensagem:

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á Python código 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
• fio
• 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
• fio
• Matriz de bytes
• Objeto CRL básico (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 de Azure. Messaging.EventHubs diretamente. Consulte Register Azure clientes 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>.