bus di servizio di Azure binding di output per Funzioni di Azure

Il modello di programmazione Python v2 consente di definire associazioni usando elementi Decorator direttamente nel codice della funzione Python. Per altre informazioni, vedere la guida per sviluppatori Python.

Il modello di programmazione Python v1 richiede di definire associazioni in un file separato function.json nella cartella della funzione. Per altre informazioni, vedere la guida per sviluppatori Python.

Questo codice definisce e inizializza :ILogger

private readonly ILogger<ServiceBusReceivedMessageFunctions> _logger;

public ServiceBusReceivedMessageFunctions(ILogger<ServiceBusReceivedMessageFunctions> logger)
{
    _logger = logger;
}

Questo esempio mostra una funzione C# che riceve un messaggio e la scrive in una seconda coda:

[Function(nameof(ServiceBusReceivedMessageFunction))]
[ServiceBusOutput("outputQueue", Connection = "ServiceBusConnection")]
public string ServiceBusReceivedMessageFunction(
    [ServiceBusTrigger("queue", Connection = "ServiceBusConnection")] ServiceBusReceivedMessage message)
{
    _logger.LogInformation("Message ID: {id}", message.MessageId);
    _logger.LogInformation("Message Body: {body}", message.Body);
    _logger.LogInformation("Message Content-Type: {contentType}", message.ContentType);

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

Questo esempio usa un trigger HTTP con un OutputType oggetto per inviare una risposta HTTP e scrivere il messaggio di output.

[Function("HttpSendMsg")]
public async Task<OutputType> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req, FunctionContext context)
{
   _logger.LogInformation($"C# HTTP trigger function processed a request for {context.InvocationId}.");

   HttpResponseData response = req.CreateResponse(HttpStatusCode.OK);
   await response.WriteStringAsync("HTTP response: Message sent");

   return new OutputType()
   {
       OutputEvent = "MyMessage",
       HttpResponse = response
   };
}

Questo codice definisce il tipo di output multiplo OutputType, che include la definizione dell'associazione di output bus di servizio in OutputEvent:

 public class OutputType
{
   [ServiceBusOutput("TopicOrQueueName", Connection = "ServiceBusConnection")]
   public string OutputEvent { get; set; }

   public HttpResponseData HttpResponse { get; set; }
}

L'esempio seguente mostra una funzione C# che invia un messaggio della coda bus di servizio:

[FunctionName("ServiceBusOutput")]
[return: ServiceBus("myqueue", Connection = "ServiceBusConnection")]
public static string ServiceBusOutput([HttpTrigger] dynamic input, ILogger log)
{
    log.LogInformation($"C# function processed: {input.Text}");
    return input.Text;
}

Anziché usare l'istruzione return per inviare il messaggio, questa funzione trigger HTTP restituisce una risposta HTTP diversa dal messaggio di output.

[FunctionName("HttpTrigger1")]
public static async Task<IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, 
[ServiceBus("TopicOrQueueName", Connection = "ServiceBusConnection")] IAsyncCollector<string> message, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    await message.AddAsync("MyMessage");
    await message.AddAsync("MyMessage2");

    string responseMessage = "This HTTP triggered sent a message to Service Bus.";

    return new OkObjectResult(responseMessage);
}

L'esempio seguente mostra una funzione TypeScript attivata dal timer che invia un messaggio di coda ogni 5 minuti.

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.serviceBusQueue({
        queueName: 'testqueue',
        connection: 'MyServiceBusConnection',
    }),
    handler: timerTrigger1,
});

Per restituire più messaggi, restituire una matrice anziché un singolo oggetto. Ad esempio:

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

Gli esempi typeScript non sono documentati per il modello v3.

L'esempio seguente mostra una funzione JavaScript attivata dal timer che invia un messaggio di coda ogni 5 minuti.

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

const serviceBusOutput = output.serviceBusQueue({
    queueName: 'testqueue',
    connection: 'MyServiceBusConnection',
});

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

Per restituire più messaggi, restituire una matrice anziché un singolo oggetto. Ad esempio:

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

L'esempio seguente mostra un'associazione di output bus di servizio in un file function.json e una funzione JavaScript che usa l'associazione. La funzione usa un trigger timer per inviare un messaggio della coda ogni 15 secondi.

Ecco i dati di associazione nel file function.json:

{
    "bindings": [
        {
            "schedule": "0/15 * * * * *",
            "name": "myTimer",
            "runsOnStartup": true,
            "type": "timerTrigger",
            "direction": "in"
        },
        {
            "name": "outputSbQueue",
            "type": "serviceBus",
            "queueName": "testqueue",
            "connection": "MyServiceBusConnection",
            "direction": "out"
        }
    ],
    "disabled": false
}

Ecco il codice script JavaScript che crea un singolo messaggio:

module.exports = async function (context, myTimer) {
    var message = 'Service Bus queue message created at ' + timeStamp;
    context.log(message);   
    context.bindings.outputSbQueue = message;
};

Ecco il codice script JavaScript che crea più messaggi:

module.exports = async function (context, myTimer) {
    var message = 'Service Bus queue message created at ' + timeStamp;
    context.log(message);   
    context.bindings.outputSbQueue = [];
    context.bindings.outputSbQueue.push("1 " + message);
    context.bindings.outputSbQueue.push("2 " + message);
};

In questo esempio viene illustrato come scrivere in un argomento bus di servizio.

import logging
import azure.functions as func

app = func.FunctionApp()

@app.route(route="put_message")
@app.service_bus_topic_output(arg_name="message",
                              connection="AzureServiceBusConnectionString",
                              topic_name="outTopic")
def main(req: func.HttpRequest, message: func.Out[str]) -> func.HttpResponse:
    input_msg = req.params.get('message')
    message.set(input_msg)
    return 'OK'

Questo esempio illustra come scrivere in una coda bus di servizio.

import azure.functions as func

app = func.FunctionApp()

@app.route(route="put_message")
@app.service_bus_queue_output(
    arg_name="msg",
    connection="AzureServiceBusConnectionString",
    queue_name="outqueue")
def put_message(req: func.HttpRequest, msg: func.Out[str]):
    msg.set(req.get_body().decode('utf-8'))
    return 'OK'

Una definizione di associazione bus di servizio viene definita in function.json in cui type è impostato su serviceBus. In questo esempio viene illustrato come scrivere in un argomento bus di servizio.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "serviceBus",
      "direction": "out",
      "connection": "AzureServiceBusConnectionString",
      "name": "msg",
      "topicName": "outTopic"
    }
  ]
}

In _init_.py è possibile scrivere un messaggio nella coda passando un valore al set metodo .

import azure.functions as func

def main(req: azf.HttpRequest, msg: azf.Out[str]):
    msg.set(req.get_body().decode('utf-8'))

    return 'OK'

Questo esempio illustra come scrivere in una coda bus di servizio.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "serviceBus",
      "direction": "out",
      "connection": "AzureServiceBusConnectionString",
      "name": "msg",
      "queueName": "outqueue"
    }
  ]
}

import azure.functions as func

def main(req: func.HttpRequest, msg: func.Out[str]) -> func.HttpResponse:

    input_msg = req.params.get('message')

    msg.set(input_msg)

    return 'OK'

Nelle librerie di classi C# usare ServiceBusOutputAttribute per definire la coda o l'argomento scritto dall'output.

La tabella seguente illustra le proprietà che è possibile impostare usando l'attributo :

Nelle librerie di classi C# usare ServiceBusAttribute.

La tabella seguente illustra le proprietà che è possibile impostare usando l'attributo :

Ecco un esempio che mostra l'attributo applicato al valore restituito della funzione:

[FunctionName("ServiceBusOutput")]
[return: ServiceBus("myqueue")]
public static string Run([HttpTrigger] dynamic input, ILogger log)
{
    ...
}

È possibile impostare la proprietà Connection per specificare il nome di un'impostazione dell'app contenente il bus di servizio stringa di connessione da usare, come illustrato nell'esempio seguente:

[FunctionName("ServiceBusOutput")]
[return: ServiceBus("myqueue", Connection = "ServiceBusConnection")]
public static string Run([HttpTrigger] dynamic input, ILogger log)
{
    ...
}

Per un esempio completo, vedere Esempio.

È possibile usare l'attributo ServiceBusAccount per specificare l'account bus di servizio da usare a livello di classe, metodo o parametro. Per altre informazioni, vedere Attributi nel riferimento al trigger.

Nella tabella seguente vengono illustrate le proprietà che è possibile impostare sull'oggetto options passato al output.serviceBusQueue() metodo .

Nella tabella seguente vengono illustrate le proprietà che è possibile impostare sull'oggetto options passato al output.serviceBusTopic() metodo .

Nella tabella seguente sono illustrate le proprietà di configurazione dell'associazione impostate nel file function.json.

Usare il tipo ServiceBusMessage quando si inviano messaggi con metadati. I parametri sono definiti come return attributi di tipo. Usare un oggetto ICollector<T> o IAsyncCollector<T> per scrivere più messaggi. Quando si chiama il metodo Add viene creato un messaggio.

Quando il valore del parametro è Null quando la funzione viene chiusa, Funzioni non crea un messaggio.

È anche possibile usare il ServiceBusAccountAttribute per specificare l'account bus di servizio da usare. Il costruttore accetta il nome di un'impostazione dell'app che contiene un bus di servizio stringa di connessione. L'attributo può essere applicato a livello di parametro, metodo o classe. L'esempio seguente illustra il livello classe e il livello metodo:

[ServiceBusAccount("ClassLevelServiceBusAppSetting")]
public static class AzureFunctions
{
    [ServiceBusAccount("MethodLevelServiceBusAppSetting")]
    [FunctionName("ServiceBusQueueTriggerCSharp")]
    public static void Run(
        [ServiceBusTrigger("myqueue", AccessRights.Manage)] 
        string myQueueItem, ILogger log)
{
    ...
}

L'account bus di servizio da usare è determinato nell'ordine seguente:

• La proprietà ServiceBusTrigger dell'attributo Connection.
• L'attributo ServiceBusAccount applicato allo stesso parametro dell'attributo ServiceBusTrigger.
• L'attributo ServiceBusAccount applicato alla funzione.
• L'attributo ServiceBusAccount applicato alla classe.
• Impostazione dell'app AzureWebJobsServiceBus .

Usare il tipo di messaggio quando si inviano messaggi con metadati. I parametri sono definiti come return attributi di tipo. Usare un oggetto ICollector<T> o IAsyncCollector<T> per scrivere più messaggi. Quando si chiama il metodo Add viene creato un messaggio.

Il 30 settembre 2026 ritireremo le librerie bus di servizio di Azure SDK WindowsAzure.ServiceBus, Microsoft.Azure. ServiceBus e com.microsoft.azure. bus di servizio, che non sono conformi alle linee guida Azure SDK. Verrà terminato anche il supporto del protocollo SBMP, quindi non sarà più possibile usare questo protocollo dopo il 30 settembre 2026. Eseguire la migrazione alle librerie di Azure SDK più recenti, che offrono aggiornamenti della sicurezza critici e funzionalità migliorate, prima di tale data.

Anche se le librerie precedenti possono ancora essere usate oltre il 30 settembre 2026, non riceveranno più il supporto e gli aggiornamenti ufficiali da Microsoft. Per altre informazioni, vedere l'annuncio del ritiro del supporto.

Quando il valore del parametro è Null quando la funzione viene chiusa, Funzioni non crea un messaggio.

È anche possibile usare il ServiceBusAccountAttribute per specificare l'account bus di servizio da usare. Il costruttore accetta il nome di un'impostazione dell'app che contiene un bus di servizio stringa di connessione. L'attributo può essere applicato a livello di parametro, metodo o classe. L'esempio seguente illustra il livello classe e il livello metodo:

[ServiceBusAccount("ClassLevelServiceBusAppSetting")]
public static class AzureFunctions
{
    [ServiceBusAccount("MethodLevelServiceBusAppSetting")]
    [FunctionName("ServiceBusQueueTriggerCSharp")]
    public static void Run(
        [ServiceBusTrigger("myqueue", AccessRights.Manage)] 
        string myQueueItem, ILogger log)
{
    ...
}

L'account bus di servizio da usare è determinato nell'ordine seguente:

• La proprietà ServiceBusTrigger dell'attributo Connection.
• L'attributo ServiceBusAccount applicato allo stesso parametro dell'attributo ServiceBusTrigger.
• L'attributo ServiceBusAccount applicato alla funzione.
• L'attributo ServiceBusAccount applicato alla classe.
• Impostazione dell'app AzureWebJobsServiceBus .

Usare il tipo BrokeredMessage quando si inviano messaggi con metadati. I parametri sono definiti come return attributi di tipo. Quando il valore del parametro è Null quando la funzione viene chiusa, Funzioni non crea un messaggio.

È anche possibile usare il ServiceBusAccountAttribute per specificare l'account bus di servizio da usare. Il costruttore accetta il nome di un'impostazione dell'app che contiene un bus di servizio stringa di connessione. L'attributo può essere applicato a livello di parametro, metodo o classe. L'esempio seguente illustra il livello classe e il livello metodo:

[ServiceBusAccount("ClassLevelServiceBusAppSetting")]
public static class AzureFunctions
{
    [ServiceBusAccount("MethodLevelServiceBusAppSetting")]
    [FunctionName("ServiceBusQueueTriggerCSharp")]
    public static void Run(
        [ServiceBusTrigger("myqueue", AccessRights.Manage)] 
        string myQueueItem, ILogger log)
{
    ...
}

L'account bus di servizio da usare è determinato nell'ordine seguente:

• La proprietà ServiceBusTrigger dell'attributo Connection.
• L'attributo ServiceBusAccount applicato allo stesso parametro dell'attributo ServiceBusTrigger.
• L'attributo ServiceBusAccount applicato alla funzione.
• L'attributo ServiceBusAccount applicato alla classe.
• Impostazione dell'app AzureWebJobsServiceBus .

Quando si vuole che la funzione scriva un singolo messaggio, l'associazione di output bus di servizio può essere associata ai tipi seguenti:

Quando si vuole che la funzione scriva più messaggi, l'associazione di output bus di servizio può essere associata ai tipi seguenti:

Per altri scenari di output, creare e usare un ServiceBusClient con altri tipi di Azure. Messaging.ServiceBus direttamente. Vedere Register Azure client per un esempio di utilizzo dell'inserimento delle dipendenze per creare un tipo di client dal Azure SDK.

Le versioni precedenti di questa estensione nel processo di lavoro isolato supportano solo l'associazione a tipi specifici della messaggistica. Sono disponibili altre opzioni per l'estensione 5.x e versioni successive

Le funzioni versione 1.x non supportano il processo di lavoro isolato. Per usare il modello di lavoro isolato, aggiornare l'applicazione a Funzioni 4.x.

Accedere al messaggio di output restituendo direttamente il valore o usando context.extraOutputs.set().

Accedere al messaggio di output usando context.bindings.<name> dove <name> è il valore specificato nella name proprietà di function.json.