Azure Functions bindings are a declarative way to connect to data and services. They simplify your code by abstracting away the details of how your function interacts with other resources. Bindings allow you to configure your function to receive data as parameters, and to output data to other services, without writing boilerplate code for connection management, serialization, or deserialization.

The Power of Bindings

Bindings in Azure Functions enable two primary types of integration:

  • Input Bindings: Make data from other services available as parameters in your function.
  • Output Bindings: Allow your function to write data to other services.

A special type of input binding, the Trigger Binding, initiates the execution of your function based on an event.

Understanding Triggers

A trigger is a specific type of input binding that defines how your function is invoked. It's the event that causes your function to run. Common triggers include:

  • HTTP Trigger: For building web APIs and handling HTTP requests.
  • Timer Trigger: For running scheduled tasks.
  • Blob Trigger: For reacting to changes in Azure Blob Storage.
  • Queue Trigger: For processing messages from Azure Storage Queues or Azure Service Bus Queues.
  • Event Grid Trigger: For reacting to events published by Azure Event Grid.
  • Cosmos DB Trigger: For reacting to changes in Azure Cosmos DB.

HTTP Trigger Example

This trigger allows your function to be invoked via an HTTP request.

Common Use Cases:

  • Building RESTful APIs
  • Webhooks
  • Handling form submissions

Example Function Signature (JavaScript):


module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    const name = (req.query.name || req.body && req.body.name);
    const responseMessage = name
        ? 'Hello, ' + name + '!'
        : "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.";

    context.res = {
        status: 200,
        body: responseMessage
    };
};

Input and Output Bindings

Beyond triggers, numerous bindings allow for rich integration with various Azure services and beyond:

Azure Blob Storage Input Binding

Read the content of a blob from Azure Blob Storage directly into your function.

Example Function Signature (C#):


using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

public static class BlobInputExample
{
    [FunctionName("BlobInputExample")]
    public static void Run(
        [BlobTrigger("samples-workitems/{name}.txt", Connection = "AzureWebJobsStorage")] Stream myBlob,
        string name,
        [Blob("output-container/{name}-processed.txt", FileAccess.Write, Connection = "AzureWebJobsStorage")] Stream outputBlob,
        ILogger log)
    {
        log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");

        using (var reader = new StreamReader(myBlob))
        using (var writer = new StreamWriter(outputBlob))
        {
            string content = reader.ReadToEnd();
            writer.Write($"Processed content: {content.ToUpper()}");
        }
    }
}

Azure Cosmos DB Output Binding

Write documents to an Azure Cosmos DB collection.

Example Function Signature (Node.js):


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

    // Assuming myQueueItem is an object with properties that match your Cosmos DB document schema
    const documentToInsert = {
        id: context.invocationId, // Use a unique ID
        ...myQueueItem,
        processedTimestamp: new Date().toISOString()
    };

    context.bindings.outputDocument = documentToInsert;
    context.log('Successfully wrote document to Cosmos DB.');
};

Commonly Used Bindings

  • Azure Table Storage: Read and write to Azure Table Storage.
  • Service Bus: Send and receive messages from Azure Service Bus Queues and Topics.
  • Event Hubs: Ingest large volumes of event data.
  • SignalR: Push real-time notifications to connected clients.
  • Twilio: Send SMS messages.
  • SendGrid: Send emails.

Benefits of Using Bindings

  • Reduced Boilerplate: No need to manage connections or SDK clients manually.
  • Declarative Configuration: Define interactions in function.json or via attributes in code.
  • Improved Readability: Code focuses on business logic, not integration details.
  • Extensibility: Supports a wide and growing range of services.

By leveraging Azure Functions bindings, you can build powerful, event-driven applications with significantly less code and complexity.

Learn More:

Azure Functions Bindings Documentation

Azure Functions Triggers

On this page