Azure Functions Queue Input Bindings

Introduction to Queue Input Bindings

Azure Functions provides input bindings for Azure Queue Storage, allowing you to easily trigger your functions when new messages are added to a queue.

This binding makes it straightforward to process queue messages without explicitly writing code to poll or read from the queue.

Key Benefits:

• Automatic Triggering: Functions are automatically invoked when a new message arrives.
• Simplified Development: No need for manual queue operations in your function code.
• Scalability: Azure Functions handles scaling based on queue message volume.
• Reliability: Built-in error handling and message processing semantics.

Getting Started

To use a Queue Input binding, you typically define it in your function's function.json file (for JavaScript, Python, etc.) or use attributes in your C# code.

Core Concepts:

• Queue Name: The name of the Azure Storage Queue to monitor.
• Connection Setting: The name of the application setting that contains your Azure Storage connection string.

Configuration

The configuration specifies how your function connects to and interacts with the queue.

function.json Example (Non-.NET languages)

Define the binding as an in binding of type queueTrigger.

{
  "scriptFile": "run.py",
  "bindings": [
    {
      "name": "msg",
      "type": "queueTrigger",
      "direction": "in",
      "queueName": "my-input-queue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}
                

C# Attribute Example (.NET)

Use the QueueTrigger attribute on a parameter.

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

public static class QueueTriggerFunction
{
    [FunctionName("ProcessQueueMessage")]
    public static void Run(
        [QueueTrigger("my-input-queue", Connection = "AzureWebJobsStorage")] string myQueueItem,
        ILogger log)
    {
        log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
    }
}
                

Connection Strings

Ensure that the connection string specified (e.g., AzureWebJobsStorage) is correctly configured in your Azure Functions application settings.

Usage Examples

Once configured, your function will be invoked with the message content.

Accessing the Message

The message content is typically passed as a string, JSON object, or custom object, depending on your language and how you bind it.

Python Example

import logging
import json

import azure.functions as func

def main(msg: func.QueueMessage) -> None:
    logging.info('Python queue trigger function processed a queue item: %s',
                 msg.get_body().decode('utf-8'))
    message_body = msg.get_body().decode('utf-8')
    try:
        data = json.loads(message_body)
        logging.info(f"Parsed JSON data: {data}")
    except json.JSONDecodeError:
        logging.warning("Message is not valid JSON.")
                

C# Example (with complex object)

If your queue messages are JSON, you can bind them directly to a C# class.

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

public class MyQueueItem
{
    public string Name { get; set; }
    public int Value { get; set; }
}

public static class QueueTriggerComplex
{
    [FunctionName("ProcessComplexQueueMessage")]
    public static void Run(
        [QueueTrigger("my-json-queue", Connection = "AzureWebJobsStorage")] MyQueueItem myQueueItem,
        ILogger log)
    {
        log.LogInformation($"C# Queue trigger function processed: Name={myQueueItem.Name}, Value={myQueueItem.Value}");
    }
}
                

Advanced Features

Queue bindings offer more advanced options for controlling message processing.

Message Properties

You can access additional message properties like insertion time and message ID by binding to specific types.

Error Handling

Functions automatically implement a retry policy for transient errors. For persistent errors, messages can be moved to a poison queue.

Batching (Preview)

For higher throughput scenarios, consider using the preview batching capabilities to process multiple messages at once.