Azure Functions Binding Patterns

Bindings in Azure Functions allow you to declaratively connect your function code to other Azure services and external data sources without needing to write boilerplate code for service clients. This guide explores common binding patterns used to enhance function development.

Key Concepts

Input Bindings: Provide data to your function from an external service.

Output Bindings: Send data from your function to an external service.

Trigger Bindings: Define how a function is invoked.

Input Binding Patterns

Input bindings simplify retrieving data into your function. They can be used to fetch single items, collections, or even trigger subsequent operations.

1. Single Input

This is the most common pattern where a single item is passed into your function based on a trigger parameter or another input binding.

Example: Reading a document from Azure Cosmos DB

Using a Cosmos DB input binding to fetch a document by its ID.


{
  "scriptFile": "run.csx",
  "entryPoint": "Run",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get"]
    },
    {
      "type": "cosmosDB",
      "direction": "in",
      "name": "item",
      "databaseName": "mydatabase",
      "collectionName": "mycollection",
      "id": "{Query.id}",
      "connectionStringSetting": "CosmosDBConnection"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ]
}

In your function code (e.g., C#), the item parameter would hold the document:


public static async Task Run(
    HttpRequest req,
    MyDocumentType item, // The input binding provides the document here
    ILogger log)
{
    if (item == null)
    {
        return new NotFoundResult();
    }
    return new OkObjectResult(item);
}

2. Collection Input

When you need to retrieve multiple items, you can use collection input bindings. This is useful for fetching all items matching certain criteria or all items in a container.

Example: Reading all messages from a Queue

Fetching multiple messages from an Azure Storage Queue.


{
  "scriptFile": "run.csx",
  "entryPoint": "Run",
  "bindings": [
    {
      "type": "queueTrigger",
      "direction": "in",
      "name": "messages",
      "queueName": "myqueue",
      "connection": "AzureWebJobsStorage"
    },
    {
      "type": "blob",
      "direction": "out",
      "name": "outputBlob",
      "path": "output/{sys.randguid}.txt",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

The messages parameter would be a collection of queue messages.


public static void Run(
    string[] messages, // Collection of messages from the queue
    out string outputBlob,
    ILogger log)
{
    log.LogInformation($"Processing {messages.Length} messages.");
    outputBlob = string.Join("\n", messages);
}

Output Binding Patterns

Output bindings are used to send data generated by your function to other services. This decouples your function logic from service integration details.

1. Single Output

Sending a single piece of data to a service.

Example: Sending a message to an Azure Service Bus Queue

Writing a string to a Service Bus queue.


{
  "scriptFile": "run.csx",
  "entryPoint": "Run",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["post"]
    },
    {
      "type": "serviceBus",
      "direction": "out",
      "name": "outputMessage",
      "queueName": "messages-out",
      "connection": "ServiceBusConnection"
    }
  ]
}

The outputMessage parameter is set to send data.


public static void Run(
    HttpRequest req,
    out string outputMessage, // This string will be sent to the Service Bus queue
    ILogger log)
{
    string requestBody = new StreamReader(req.Body).ReadToEndAsync().Result;
    outputMessage = requestBody; // Set the output binding value
    log.LogInformation("Message sent to Service Bus.");
}

2. Batch Output

While not a direct binding type, you can simulate batch output by writing multiple items to a service that supports batch operations, or by using output bindings that can handle collections.

Advanced Binding Patterns

1. Dynamic Output

You can dynamically determine the output binding target or the data to send based on your function's logic.

Example: Writing to different Blob Containers

Deciding which blob container to write to based on incoming data.


{
  "scriptFile": "run.csx",
  "entryPoint": "Run",
  "bindings": [
    {
      "type": "queueTrigger",
      "direction": "in",
      "name": "message",
      "queueName": "processing-queue",
      "connection": "AzureWebJobsStorage"
    },
    {
      "type": "blob",
      "direction": "out",
      "name": "outputBlob",
      "path": "output/{MessageId}/{sys.randguid}.txt", // Dynamic path
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Here, the MessageId from the queue message influences the output blob path.

2. Triggering Other Functions (Orchestration)

Bindings can be used to invoke other Azure Functions, often within an orchestration context (like Durable Functions) to build complex workflows.

While direct invocation via bindings is less common for simple HTTP triggers, the concept is fundamental to orchestrator patterns where an orchestrator output binding can trigger another function or activity.

3. Binding to Collections of Data

Some triggers and bindings support receiving or sending collections of items, facilitating batch processing.

Example: Batch Input from Cosmos DB

Fetching multiple documents from Cosmos DB based on a query that returns a collection.


{
  "scriptFile": "run.csx",
  "entryPoint": "Run",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get"],
      "authLevel": "function"
    },
    {
      "type": "cosmosDB",
      "direction": "in",
      "name": "items",
      "databaseName": "mydatabase",
      "collectionName": "mycollection",
      "SqlQuery": "SELECT * FROM c WHERE c.category = {Query.category}", // Query returns multiple items
      "connectionStringSetting": "CosmosDBConnection"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ]
}

The items parameter will be a collection (e.g., IReadOnlyList<MyDocumentType> in C#).

Conclusion

Mastering Azure Functions binding patterns is crucial for building efficient, scalable, and maintainable serverless applications. By leveraging bindings, you can focus on your business logic rather than the intricacies of service integrations.

Azure Functions Docs