Azure Functions Triggers and Bindings

Azure Functions uses triggers and bindings to enable event-driven programming. Triggers define how a function is executed, while bindings allow you to connect to other Azure services and data sources.

This document explores the various types of triggers and bindings available for Azure Functions, providing guidance on how to use them effectively in your serverless applications.

Understanding Triggers

A trigger is what causes a function to execute. It defines the event that starts a function's run. For example, an HTTP request, a new message in a storage queue, or a timer schedule can all act as triggers.

Common Trigger Types:

HTTP Trigger: Executes in response to an HTTP request.
Timer Trigger: Executes on a schedule defined by a CRON expression.
Blob Trigger: Executes when a new or updated blob is detected in Azure Blob Storage.
Queue Trigger: Executes when a new message arrives in an Azure Storage Queue.
Event Hubs Trigger: Executes in response to events sent to an Azure Event Hubs.
Service Bus Trigger: Executes in response to messages in an Azure Service Bus Queue or Topic.
Cosmos DB Trigger: Executes when changes are detected in a Cosmos DB collection.

Each trigger has specific properties and configuration settings that you'll need to define in your function's configuration (typically function.json).

Understanding Bindings

Bindings provide a declarative way to connect your function to Azure services and other data sources without writing explicit SDK code within your function. Bindings can be used for both input and output operations.

Input Bindings:

Input bindings make data from a service available as parameters to your function. For example, an HTTP trigger can have an input binding to retrieve a blob's content.

Output Bindings:

Output bindings enable your function to write data to a service. For instance, after processing a message, your function can use an output binding to write results to Azure Table Storage.

Common Binding Types:

HTTP Binding: For creating HTTP-triggered functions and returning HTTP responses.
Blob Storage Binding: For reading from and writing to Azure Blob Storage.
Table Storage Binding: For reading from and writing to Azure Table Storage.
Queue Storage Binding: For reading messages from and writing messages to Azure Storage Queues.
Service Bus Binding: For sending and receiving messages from Azure Service Bus.
Event Hubs Binding: For sending and receiving events from Azure Event Hubs.
Cosmos DB Binding: For interacting with Azure Cosmos DB.
Document DB Binding: For interacting with Azure DocumentDB (now Cosmos DB).

Configuring Triggers and Bindings

Triggers and bindings are configured in the function.json file. Here's an example of a function triggered by an HTTP request and writing to a blob:


{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "blob",
      "direction": "out",
      "name": "outputBlob",
      "path": "output-container/{rand-guid}.txt",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

In this example:

The first binding is an httpTrigger that accepts GET and POST requests.
The second binding is an http output binding to return an HTTP response.
The third binding is a blob output binding that writes to a blob named with a random GUID in the output-container, using the default storage connection.

Note on Connections

Bindings often require a connection string to access Azure services. These are typically configured in your application settings as environment variables (e.g., AzureWebJobsStorage) or in a local.settings.json file for local development.

Advanced Scenarios

Trigger and Binding Expressions

You can use expressions within your trigger and binding configurations to dynamically set values. These expressions can reference properties from the trigger payload, configuration settings, and more.


// Example: Using a blob name from an HTTP request parameter
{
  "type": "blob",
  "direction": "in",
  "name": "inputBlob",
  "path": "input-container/{fileName}",
  "connection": "AzureWebJobsStorage"
}

Here, {fileName} refers to a query parameter or route parameter named fileName in the incoming HTTP request.

Custom Bindings

For scenarios not covered by the built-in bindings, Azure Functions allows you to create custom bindings. This provides maximum flexibility to integrate with any service or API.

Tutorials and Examples

Explore the following resources for practical examples and step-by-step tutorials on using specific triggers and bindings:

Tip

Always refer to the official Azure Functions documentation for the most up-to-date information on triggers, bindings, and their specific configurations.