Liaison de sortie Azure Event Hubs pour Azure Functions

Le modèle de programmation Python v2 vous permet de définir des liaisons à l'aide d’éléments décoratifs directement dans le code de votre fonction Python. Pour plus d’informations, consultez le guide des développeurs Python.

Le modèle de programmation Python v1 vous oblige à définir des liaisons dans un fichier function.json distinct dans le dossier de fonction. Pour plus d’informations, consultez le guide des développeurs Python.

L’exemple suivant illustre une fonction C# qui écrit une chaîne de messages dans un Event Hub, en utilisant la valeur renvoyée par la méthode comme sortie :

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

L’exemple suivant illustre une fonction C# qui écrit un message dans un hub d’événements, en utilisant la valeur retournée par la méthode comme sortie :

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

L’exemple suivant montre comment utiliser l’interface IAsyncCollector pour envoyer un lot de messages. Ce scénario est courant lorsque vous traitez des messages provenant d’un hub d’événements et que vous envoyez le résultat à un autre hub d’événements.

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

L’exemple suivant montre une fonction TypeScript déclenchée par le minuteur qui envoie un seul message à un Event hub :

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

Pour générer plusieurs messages, retournez un tableau au lieu d’un seul objet. Par exemple :

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

Les exemples TypeScript ne sont pas documentés pour le modèle v3.

L’exemple suivant montre une fonction JavaScript déclenchée par le minuteur qui envoie un seul message à un Event hub :

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

Pour générer plusieurs messages, retournez un tableau au lieu d’un seul objet. Par exemple :

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

L’exemple suivant illustre une liaison de déclencheur d’Event Hub dans un fichier function.json et une fonction qui utilise la liaison. La fonction écrit un message de sortie dans un Event Hub.

L’exemple suivant montre des données de liaison Event Hubs dans le fichier function.json, qui est différent pour la version 1.x du runtime Functions par rapport aux versions ultérieures.

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

Voici le code JavaScript qui envoie un message unique :

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

Voici le code JavaScript qui envoie plusieurs messages :

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'

Voici le code Python qui envoie plusieurs messages :

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

Les exemples suivants illustrent les données de liaison Event Hubs dans le fichier function.json.

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

Voici le code Python qui envoie un message unique :

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)

Voici le code Python qui envoie plusieurs messages :

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

Utilisez l’attribut [EventHubOutputAttribute] pour définir une liaison de sortie vers un Event Hub, qui prend en charge les propriétés suivantes.

Utilisez l’attribut EventHubAttribute pour définir une liaison de sortie vers un Event Hub, qui prend en charge les propriétés suivantes.

Le tableau suivant explique les propriétés que vous pouvez définir pour l’objet options passé à la méthode output.eventHub().

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le fichier function.json.

Les fonctions de la bibliothèque de classes C# In-process prennent en charge les types suivants :

• Azure.Messaging.EventHubs.EventData
• String
• Tableau d’octets
• Objet CLR traditionnel (OCT)

Cette version d’EventData ne prend plus en charge le type hérité Body en faveur d’EventBody.

Envoyez des messages en utilisant un paramètre de méthode comme out string paramName. Pour écrire plusieurs messages, vous pouvez utiliser ICollector<EventData> ou IAsyncCollector<EventData> à la place de out string. Les clés de partition ne peuvent être utilisées qu’avec IAsyncCollector<EventData>.

Les fonctions de la bibliothèque de classes C# In-process prennent en charge les types suivants :

• Microsoft.Azure.EventHubs.EventData
• String
• Tableau d’octets
• Objet CLR traditionnel (OCT)

Envoyez des messages en utilisant un paramètre de méthode comme out string paramName. Pour écrire plusieurs messages, vous pouvez utiliser ICollector<string> ou IAsyncCollector<string> à la place de out string.

Lorsque vous souhaitez que la fonction écrive un seul événement, la liaison de sortie Event Hubs peut se lier aux types suivants :

Lorsque vous souhaitez que la fonction écrive plusieurs événements, la liaison de sortie Event Hubs peut se lier aux types suivants :

Pour d’autres scénarios de sortie, créez et utilisez un EventHubProducerClient avec d’autres types à partir d’Azure.Messaging.EventHubs directement. Consultez Inscrire des clients Azure pour obtenir un exemple d’utilisation de l’injection de dépendances pour créer un type de client à partir du Kit de développement logiciel (SDK) Azure.

Requiert la définition d’un type personnalisé ou l’utilisation d’une chaîne. Des options supplémentaires sont disponibles dans Extension v5.x+.

Accédez au message de sortie en retournant la valeur directement ou en utilisant context.extraOutputs.set().

Accédez à l’événement de sortie à l’aide de context.bindings.<name> où <name> est la valeur spécifiée dans la propriété name de context.bindings.<name>.