Azure Functions Documentation

Blob Output Binding

The Azure Blob Storage output binding for Azure Functions allows your function to write data to a blob container in Azure Blob Storage. This binding simplifies the process of storing output from your function directly into blob storage without needing to explicitly use the Azure Blob Storage SDK in your function code.

How it Works

When you configure a blob output binding, you specify the path and filename for the blob to be created or overwritten. The Azure Functions runtime handles the connection to your storage account and the writing of data to the specified blob.

Configuration

You configure bindings in your function's function.json file (for JavaScript, C#, Python, etc.) or using attributes in code (for C#, F#).

Example function.json:

{
  "bindings": [
    {
      "name": "inputQueueItem",
      "type": "queueTrigger",
      "direction": "in",
      "queueName": "myqueue-items",
      "connection": "AzureWebJobsStorage"
    },
    {
      "name": "outputBlob",
      "type": "blob",
      "direction": "out",
      "path": "output-container/{name}.txt",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

In this example:

• name: "outputBlob": This is the name of the parameter in your function code that will receive the blob output.
• type: "blob": Specifies that this is a blob binding.
• direction: "out": Indicates this is an output binding.
• path: "output-container/{name}.txt": Defines the destination.
  • output-container is the name of the blob container.
  • {name}.txt is the filename. The {name} token is a placeholder that gets its value from the incoming trigger (in this case, the queue message content might be parsed to extract a 'name' property, or it might be a default value or generated).
• connection: "AzureWebJobsStorage": Refers to an application setting (usually in local.settings.json or Azure portal configuration) that holds the connection string for your Azure Storage account.

Using the Binding in Code

Node.js Example:

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

    // Assuming inputQueueItem is a string or JSON object that can be serialized
    // If inputQueueItem is an object and you want to write it as JSON:
    // context.bindings.outputBlob = JSON.stringify(inputQueueItem, null, 2);

    // If you want to use a property from the input as part of the blob path:
    // For example, if inputQueueItem = { "name": "mydata", "content": "Some content here" }
    // and your function.json path is "output-container/{name}.txt"
    // The runtime automatically uses inputQueueItem.name if it exists.

    // For simple string output:
    context.bindings.outputBlob = `Data for ${inputQueueItem}: ${new Date().toISOString()}`;

    context.log(`Blob output written to ${context.bindingData.blobTrigger}`);
};

C# Example:

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

public static class MyBlobOutputFunction
{
    [FunctionName("BlobOutputTrigger")]
    public static void Run(
        [QueueTrigger("myqueue-items")] string inputQueueItem,
        [Blob("output-container/{name}.txt", FileAccess.Write)] out string outputBlob,
        string name, // This 'name' parameter will be populated by the runtime based on the path token
        ILogger log)
    {
        log.LogInformation($"C# Queue trigger function processed work item: {inputQueueItem}");

        // Use the 'name' parameter from the trigger or path definition
        outputBlob = $"Processed data for item: {inputQueueItem} at {System.DateTime.UtcNow}";

        log.LogInformation($"Blob output written for name: {name}");
    }
}

Blob Path Customization

The path property in the binding configuration is powerful. You can use tokens to dynamically set the blob name and container based on the input trigger or other context.

• Container and Blob Name from Trigger Data: If your trigger provides data (e.g., an HTTP request with a route parameter, or a blob trigger with a filename), you can use those values in the path. In the C# example, string name maps to the {name} token in the path.
• Date/Time Tokens: You can use tokens like {yyyy}, {MM}, {dd}, {hh}, {mm}, {ss} to create time-based folder structures or filenames. For example: "path": "logs/{yyyy}/{MM}/{dd}/{name}.log".
• Function Variables: Some properties like RandGuid can be used to generate unique identifiers.

Supported Blob Types

The blob output binding supports writing various types:

• String: Writes the string content directly to the blob.
• Byte Array (byte[]): Writes raw binary data.
• Stream: Writes data from a stream.
• Custom Objects (Serialization): For languages like C# and Node.js, you can often assign complex objects, and the runtime will attempt to serialize them (e.g., to JSON) before writing.

Key Considerations

• Ensure the storage account connection string in your local.settings.json or application settings is correct.
• The container specified in the path must exist or your function may fail (though some runtimes might create it implicitly). It's best practice to ensure the container exists beforehand.
• Be mindful of file naming conventions and potential conflicts, especially in high-throughput scenarios.