Enlace de salida de Azure Event Hubs para Azure Functions

El modelo de programación de Python v2 permite definir enlaces mediante decoradores directamente en el código de función de Python. Para más información, consulte la Guía para desarrolladores de Python.

El modelo de programación de Python v1 requiere que defina enlaces en un archivo function.json independiente en la carpeta de funciones. Para más información, consulte la Guía para desarrolladores de Python.

En el ejemplo siguiente se muestra una función de C# que escribe una cadena de mensaje en un centro de eventos usando el valor devuelto del método como resultado:

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

En el ejemplo siguiente se muestra una función de C# que escribe un mensaje en un centro de eventos usando el valor devuelto del método como resultado:

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

En el siguiente ejemplo se muestra cómo usar la interfaz IAsyncCollector para enviar un lote de mensajes. Este escenario es habitual cuando se procesan mensajes procedentes de un centro de eventos y el resultado se envía a otro centro 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");
    }
}

En el ejemplo siguiente se muestra un temporizador desencadenado Función TypeScript que envía un único mensaje a un centro 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 generar varios mensajes, devuelva una matriz en lugar de un solo objeto. Por ejemplo:

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

Los ejemplos de TypeScript no están documentados para el modelo v3.

En el ejemplo siguiente se muestra un temporizador desencadenado Función de JavaScript que envía un único mensaje a un centro 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 generar varios mensajes, devuelva una matriz en lugar de un solo objeto. Por ejemplo:

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

En el ejemplo siguiente se muestra un enlace de desencadenador de centro de eventos en un archivo function.json, así como una función que usa el enlace. La función escribe un mensaje de salida a un centro de eventos.

En el ejemplo siguiente se muestran los datos de vinculación de Event Hubs en el archivo function.json, que es diferente para la versión 1.x del tiempo de ejecución de Functions en comparación con las versiones posteriores.

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

Este es el código JavaScript que envía un mensaje:

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 es el código JavaScript que envía varios mensajes:

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'

Este es el código de Python que envía varios mensajes:

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")

Los ejemplos siguientes muestran datos de enlace de Event Hubs en el archivo function.json.

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

Este es el código de Python que envía un solo mensaje:

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)

Este es el código de Python que envía varios mensajes:

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 [EventHubOutputAttribute] para definir un enlace de salida a un centro de eventos, que admite las siguientes propiedades.

Use EventHubAttribute para definir un enlace de salida a un centro de eventos, que admite las siguientes propiedades.

En la tabla siguiente se explican las propiedades que puede establecer en el objeto options que se pasa al métodooutput.eventHub().

En la siguiente tabla se explican las propiedades de configuración de enlace que se establecen en el archivo function.json.

Las funciones de la biblioteca de clases de C# en proceso admiten los siguientes tipos:

• Azure.Messaging.EventHubs.EventData
• String
• Byte array
• Objeto CLR convencional (POCO)

En esta versión de EventData se elimina la compatibilidad con el tipo Body heredado en favor de EventBody.

Envíe mensajes mediante un parámetro de método, como out string paramName. Para escribir varios mensajes, puede usar ICollector<EventData> o IAsyncCollector<EventData> en lugar de out string. Las claves de partición solo se pueden usar con IAsyncCollector<EventData>.

Las funciones de la biblioteca de clases de C# en proceso admiten los siguientes tipos:

• Microsoft.Azure.EventHubs.EventData
• String
• Byte array
• Objeto CLR convencional (POCO)

Envíe mensajes mediante un parámetro de método, como out string paramName. Para escribir varios mensajes, puede usar ICollector<string> o IAsyncCollector<string> en lugar de out string.

Cuando quiera que la función escriba un único evento, el enlace de salida de Event Hubs puede enlazarse a los siguientes tipos:

Cuando quiera que la función escriba varios eventos, el enlace de salida de Event Hubs puede enlazarse a los siguientes tipos:

Para otros escenarios de salida, cree y use eventHubProducerClient con otros tipos de Azure.Messaging.EventHubs directamente. Consulte Registro de clientes de Azure para obtener un ejemplo de uso de la inserción de dependencias para crear un tipo de cliente a partir del SDK de Azure.

Requiere que defina un tipo personalizado o use una cadena. Hay opciones adicionales disponibles para la Extensión v5.x+.

Acceda al mensaje de salida devolviendo el valor directamente o mediante context.extraOutputs.set().

Acceda al evento de salida mediante context.bindings.<name>, donde <name> es el valor especificado en la propiedad name de context.bindings.<name>.