Azure Event Hubs utdatabindning för Azure Functions

Med programmeringsmodellen Python v2 kan du definiera bindningar med hjälp av dekoratörer direkt i din Python funktionskod. Mer information finns i utvecklarguiden Python.

Programmeringsmodellen Python v1 kräver att du definierar bindningar i en separat fil function.json i funktionsmappen. Mer information finns i utvecklarguiden Python.

I följande exempel visas en C#-funktion som skriver en meddelandesträng till en händelsehubb med metodens returvärde som utdata:

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

I följande exempel visas en C#-funktion som skriver ett meddelande till en händelsehubb med metodens returvärde som utdata:

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

I följande exempel visas hur du använder IAsyncCollector gränssnittet för att skicka en batch med meddelanden. Det här scenariot är vanligt när du bearbetar meddelanden som kommer från en händelsehubb och skickar resultatet till en annan händelsehubb.

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

I följande exempel visas en timerutlöst TypeScript-funktion som skickar ett enda meddelande till en händelsehubb:

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

Om du vill mata ut flera meddelanden returnerar du en matris i stället för ett enda objekt. Till exempel:

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

TypeScript-exempel dokumenteras inte för modell v3.

I följande exempel visas en timerutlöst JavaScript-funktion som skickar ett enda meddelande till en händelsehubb:

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

Om du vill mata ut flera meddelanden returnerar du en matris i stället för ett enda objekt. Till exempel:

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

I följande exempel visas en utlösarbindning för händelsehubben i en function.json-fil och en funktion som använder bindningen. Funktionen skriver ett utdatameddelande till en händelsehubb.

I följande exempel visas en Event Hubs-bindningsdata i filen function.json , som skiljer sig från version 1.x av Functions-körningen jämfört med senare versioner.

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

Här är JavaScript-kod som skickar ett enda meddelande:

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

Här är JavaScript-kod som skickar flera meddelanden:

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'

Här är Python kod som skickar flera meddelanden:

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

I följande exempel visas Event Hubs-bindningsdata i filen function.json .

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

Här är Python kod som skickar ett enda meddelande:

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)

Här är Python kod som skickar flera meddelanden:

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

Använd [EventHubOutputAttribute] för att definiera en utdatabindning till en händelsehubb som stöder följande egenskaper.

Använd EventHubAttribute för att definiera en utdatabindning till en händelsehubb som stöder följande egenskaper.

I följande tabell förklaras de egenskaper som du kan ange för objektet options som skickas output.eventHub() till metoden.

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json .

C#-klassbiblioteksfunktionerna i processen stöder följande typer:

• Azure. Messaging.EventHubs.EventData
• Sträng
• Bytematris
• Vanligt gammalt CLR-objekt (POCO)

Den här versionen av EventData släpper stödet för den äldre typen till förmån Body.

Skicka meddelanden med hjälp av en metodparameter som out string paramName. Om du vill skriva flera meddelanden kan du använda ICollector<EventData> eller IAsyncCollector<EventData> i stället för out string. Partitionsnycklar får endast användas med IAsyncCollector<EventData>.

C#-klassbiblioteksfunktionerna i processen stöder följande typer:

• Microsoft.Azure. EventHubs.EventData
• Sträng
• Bytematris
• Vanligt gammalt CLR-objekt (POCO)

Skicka meddelanden med hjälp av en metodparameter som out string paramName. Om du vill skriva flera meddelanden kan du använda ICollector<string> eller IAsyncCollector<string> i stället för out string.

När du vill att funktionen ska skriva en enskild händelse kan Event Hubs-utdatabindningen binda till följande typer:

När du vill att funktionen ska skriva flera händelser kan Event Hubs-utdatabindningen binda till följande typer:

För andra utdatascenarier skapar och använder du en EventHubProducerClient med andra typer från Azure. Messaging.EventHubs direkt. Se Register Azure-klienter för ett exempel på hur du använder beroendeinmatning för att skapa en klienttyp från Azure SDKs.

Kräver att du definierar en anpassad typ eller använder en sträng. Ytterligare alternativ finns i Tillägget v5.x+.

Få åtkomst till utdatameddelandet genom att returnera värdet direkt eller med hjälp av context.extraOutputs.set().

Få åtkomst till utdatahändelsen med hjälp av var context.bindings.<name> är värdet som anges i <name> egenskapen name.