Azure Functions Bindings

Understanding Azure Functions Bindings

Azure Functions bindings provide a declarative way to connect to Azure services and other resources. They simplify your code by decoupling the implementation of your function from the details of interacting with external services. Bindings can be used for both triggers (which start your function) and for input and output data.

This page details the core concepts of triggers, input bindings, and output bindings in Azure Functions, along with practical examples.

Triggers

A trigger defines how a function is invoked. Each function must have exactly one trigger. When the event defined by the trigger occurs, Azure Functions runtime invokes your function.

Common Trigger Types:

• HTTP Trigger: Invokes your function when an HTTP request is received. Ideal for building web APIs and webhooks.
• Timer Trigger: Invokes your function on a schedule, defined by a CRON expression. Useful for scheduled tasks.
• Queue Trigger: Invokes your function when a message is added to an Azure Storage Queue.
• Blob Trigger: Invokes your function when a new or updated blob is detected in an Azure Blob Storage container.
• Event Grid Trigger: Invokes your function in response to events published to Azure Event Grid.
• Service Bus Trigger: Invokes your function when a message is received by an Azure Service Bus queue or topic.

Trigger Configuration Example (HTTP Trigger):

Triggers are typically configured in the function.json file or via attributes in your code (depending on your programming model).

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using System.Net;

public static class HttpTriggerExample
{
    [Function("HttpTriggerExample")]
    public static async Task Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req,
        FunctionContext context)
    {
        var logger = context.GetLogger();
        logger.LogInformation("C# HTTP trigger function processed a request.");

        var response = req.CreateResponse(HttpStatusCode.OK);
        response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
        response.WriteString("Hello from Azure Functions!");

        return response;
    }
}
                

Input Bindings

Input bindings allow you to read data from other Azure services or external data sources within your function. The runtime retrieves the data based on the binding configuration and passes it as a parameter to your function.

Common Input Binding Scenarios:

• Retrieving a document from Azure Cosmos DB.
• Reading a message from an Azure Service Bus queue.
• Fetching configuration settings from an Azure App Configuration store.
• Accessing data from an Azure Table Storage entity.

Input Binding Configuration Example (Cosmos DB):

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

public static class CosmosDbInputExample
{
    [Function("CosmosDbInputExample")]
    public static void Run(
        [QueueTrigger("myqueue-items")] string myQueueItem,
        [CosmosDB(
            databaseName: "MyDatabase",
            collectionName: "Products",
            Id = "{queueTrigger}",
            PartitionKey = "{queueTrigger}",
            ConnectionStringSetting = "CosmosDbConnectionString")] Product product,
        FunctionContext context)
    {
        var logger = context.GetLogger();
        logger.LogInformation($"C# Queue trigger function processed: {myQueueItem}");

        if (product != null)
        {
            logger.LogInformation($"Retrieved Product: Id={product.Id}, Name={product.Name}");
            // Process the product data
        }
        else
        {
            logger.LogWarning($"Product not found for id: {myQueueItem}");
        }
    }
}

// Assume a simple Product class
public class Product
{
    public string Id { get; set; }
    public string Name { get; set; }
    // Other properties
}
                

Output Bindings

Output bindings enable your function to write data to Azure services or other external data sources. Similar to input bindings, the runtime handles the service interaction based on the output binding configuration.

Common Output Binding Scenarios:

• Sending a message to an Azure Service Bus queue.
• Saving data to Azure Table Storage or Azure SQL Database.
• Writing a blob to Azure Blob Storage.
• Returning an HTTP response.

Output Binding Configuration Example (Service Bus):

module.exports = async function (context, triggerMessage) {
    context.log('JavaScript queue trigger function processed work item', triggerMessage);

    const outputMessage = {
        id: triggerMessage.id,
        processedData: "Some processed information",
        timestamp: new Date().toISOString()
    };

    context.bindings.outputSbQueue = outputMessage;
    context.log('Sent message to Service Bus output queue.');
};
                

Binding Expressions

Binding expressions are used within binding configurations to dynamically reference data from the trigger or other bindings. They are enclosed in curly braces {}.

• {queueTrigger}: References the content of the message from a queue trigger.
• {blobName}: References the name of the blob that triggered the function.
• {WebhookData.someProperty}: References a property from the incoming HTTP request body.

These expressions make bindings highly flexible, allowing them to adapt to the specific data provided by the trigger event.

Key Takeaways

• Triggers start your function execution.
• Input bindings bring data into your function.
• Output bindings send data out of your function.
• Bindings significantly reduce boilerplate code for service integrations.
• Binding expressions provide dynamic data access.

By leveraging Azure Functions bindings, you can build robust and scalable serverless applications with cleaner, more maintainable code.