Azure Functions

Input Bindings

Input bindings in Azure Functions allow you to declaratively connect your function to other Azure services or external data sources. This means you don't need to write boilerplate code to read data from these services; the Functions runtime handles it for you.

When you define an input binding, you specify the type of binding, its name, and any necessary configuration parameters (like connection strings, table names, queue names, etc.). The runtime then automatically loads the data into your function's parameters or properties.

Common Input Bindings

Here are some frequently used input bindings:

• Blob Storage: Read blobs from Azure Blob Storage.
• Table Storage: Retrieve entities from Azure Table Storage.
• Queue Storage: Get messages from an Azure Storage Queue.
• Cosmos DB: Fetch documents from Azure Cosmos DB.
• Service Bus: Receive messages from Azure Service Bus queues or topics.
• Event Hubs: Read events from Azure Event Hubs.
• HTTP: Trigger a function via an HTTP request (often used as a trigger, but can also be used as an input to fetch external data).

How Input Bindings Work

Input bindings are configured in the function.json file (for JavaScript, Python, and other non-.NET languages) or using attributes in C# and other .NET languages.

Example: Reading a Blob

Consider a scenario where you want to read a configuration file from Blob Storage into your function.

{
  "scriptFile": "index.js",
  "bindings": [
    {
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [ "get", "post" ],
      "authLevel": "function"
    },
    {
      "name": "res",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "configBlob",
      "type": "blob",
      "direction": "in",
      "path": "configs/settings.json",
      "connection": "AzureWebJobsStorage"
    }
  ]
}
                

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

    // configBlob is automatically populated with the content of the blob
    const config = JSON.parse(configBlob);

    const name = (req.query.name || (req.body && req.body.name));
    const message = name
        ? `Hello, ${name}! Config value: ${config.apiEndpoint}`
        : "Please pass a name on the query string or in the request body. Config value: " + config.apiEndpoint;

    context.res = {
        body: message
    };
};
                

In this example, the configBlob parameter in the JavaScript code will automatically contain the content of the blob located at configs/settings.json in the storage account specified by the AzureWebJobsStorage connection string.

Table Example

You can also bind to query results from Table Storage.

{
  "scriptFile": "index.js",
  "bindings": [
    {
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [ "get" ],
      "authLevel": "function"
    },
    {
      "name": "res",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "products",
      "type": "table",
      "direction": "in",
      "tableName": "Products",
      "filter": "PartitionKey eq 'Electronics'",
      "connection": "AzureWebJobsStorage"
    }
  ]
}
                

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

    // 'products' will be an array of entities from the 'Products' table
    // that match the filter 'PartitionKey eq 'Electronics''

    if (products && products.length > 0) {
        context.res = {
            body: products
        };
    } else {
        context.res = {
            status: 404,
            body: "No electronic products found."
        };
    }
};
                

Benefits of Input Bindings

• Reduced Boilerplate: Focus on business logic, not data access.
• Declarative Configuration: Easily define data sources.
• Service Integration: Seamlessly connect to various Azure services.
• Maintainability: Simplify function code and make it easier to understand.

Explore the documentation for specific binding types to understand their configuration options and capabilities.