Azure Functions Table Output Bindings

Table output bindings enable your Azure Functions to write data to Azure Table Storage. This is a powerful and cost-effective way to store structured NoSQL data for applications that require flexible schema and high scalability.

Key Benefits

  • Scalability: Azure Table Storage scales to accommodate massive amounts of data.
  • Cost-Effectiveness: It's one of the most affordable storage options for NoSQL data.
  • Performance: Designed for high throughput and low latency.
  • Simplicity: Easy integration with Azure Functions.

How it Works

When you define a table output binding in your Azure Function's configuration (e.g., function.json), you specify the target table. Your function code can then return or add objects to this binding, and the runtime will automatically handle inserting or merging these entities into the specified table.

Configuration

A typical table output binding configuration in function.json looks like this:

{
  "bindings": [
    {
      "name": "outputTable",
      "type": "table",
      "direction": "out",
      "tableName": "MyLogEntries",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Binding Properties:

Using the Binding in Code

C# Example

In C#, you can accept an ICollector<T> or an IAsyncCollector<T> for the output binding. The type T should match the schema of your table entities.

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using System.Threading.Tasks;

public static class LogToTable
{
    public class LogEntry
    {
        public string PartitionKey { get; set; }
        public string RowKey { get; set; }
        public string Message { get; set; }
        public string Level { get; set; }
    }

    [FunctionName("LogToTable")]
    public static async Task Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
        [Table("MyLogEntries", Connection = "AzureWebJobsStorage")] IAsyncCollector<LogEntry> outputTable,
        TraceWriter log)
    {
        log.Info("C# HTTP trigger function processed a request.");

        string message = req.Query["message"];
        string level = req.Query["level"];

        if (string.IsNullOrEmpty(message) || string.IsNullOrEmpty(level))
        {
            return new BadRequestObjectResult("Please pass 'message' and 'level' in the query string");
        }

        var entry = new LogEntry
        {
            PartitionKey = "AppLogs",
            RowKey = System.Guid.NewGuid().ToString(),
            Message = message,
            Level = level
        };

        await outputTable.AddAsync(entry);

        log.Info($"Logged message: '{message}' with level '{level}' to MyLogEntries table.");

        return new OkResult();
    }
}

Node.js Example

In Node.js, the output binding is typically available as a property on the context.bindings object. You can add objects to an array associated with the binding name.

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

    const message = req.query.message;
    const level = req.query.level;

    if (!message || !level) {
        context.res = { status: 400, body: "Please pass 'message' and 'level' in the query string" };
        return;
    }

    const logEntry = {
        partitionKey: "AppLogs",
        rowKey: context.bindingData.sys.randGuid, // Generate a unique row key
        message: message,
        level: level
    };

    // Assuming the output binding is named 'outputTable' in function.json
    context.bindings.outputTable = context.bindings.outputTable || [];
    context.bindings.outputTable.push(logEntry);

    context.log(`Logged message: '${message}' with level '${level}' to MyLogEntries table.`);

    context.res = { status: 200, body: "Log entry added successfully!" };
};

Table Entity Schema

When writing to Azure Table Storage, each entity must have at least a PartitionKey and a RowKey. These two properties uniquely identify an entity within a table.

Your function code is responsible for providing these keys. Often, a GUID is used for the RowKey to ensure uniqueness, and a fixed string or dynamic value for the PartitionKey depending on your application logic.

Common Use Cases

  • Logging application events and diagnostics.
  • Storing audit trails for user actions.
  • Caching frequently accessed data.
  • Storing game scores or leaderboards.
  • Saving transient data from IoT devices.

Learn More