Azure Functions: Blob Storage Binding Tutorial

1. Set up Your Azure Storage Account

If you don't have one already, create an Azure Storage account in the Azure portal. Once created, navigate to your storage account and go to Containers. Create a new container named input-images. Note down your storage account name and access key (found under Access keys).

2. Create a New Azure Functions Project

Open your terminal or command prompt and use Azure Functions Core Tools to create a new project:

func init BlobTriggerCSharp --dotnet --target-framework net6.0
cd BlobTriggerCSharp
func new --name ProcessImage --template "Azure Blob Storage trigger"

This creates a new C# Azure Functions project and adds a function named ProcessImage.

3. Configure the Blob Storage Trigger

Open the Function.cs file for your ProcessImage function. You'll see an attribute defining the trigger. We need to configure it to point to our input-images container and set up an output binding.

First, open the local.settings.json file and add your Azure Storage connection string:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true", // Replace with your actual connection string or keep for local dev
    "FUNCTIONS_WORKER_RUNTIME": "dotnet"
  }
}

Replace UseDevelopmentStorage=true with your actual storage account connection string. You can find this in the Azure portal under your storage account's Access keys. For local development, using the Azure Storage Emulator is also an option.

Now, modify Function.cs:

using System;
using System.IO;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace BlobTriggerCSharp
{
    public static class ProcessImage
    {
        [Function("ProcessImage")]
        public static void Run(
            [BlobTrigger("input-images/{name}")] Stream inputBlob,
            [Blob("output-logs/{name}.txt")] out string outputBlob,
            string name,
            FunctionContext context)
        {
            var logger = context.GetLogger();
            logger.LogInformation($"C# Blob trigger function processed blob\n Name: {name} \n Size: {inputBlob.Length} Bytes");

            // Simulate some processing
            string processingResult = $"Successfully processed blob: {name}. Size: {inputBlob.Length} bytes.";

            // Write the result to the output blob
            outputBlob = processingResult;

            logger.LogInformation($"Output log written for blob: {name}");
        }
    }
}

In this code:

• [BlobTrigger("input-images/{name}")]: This defines the input binding. The function triggers when a blob is added to the input-images container. {name} is a placeholder that captures the blob's name.
• [Blob("output-logs/{name}.txt")] out string outputBlob: This defines an output binding. It specifies that a string named outputBlob will be written to a blob named after the input blob (with a .txt extension) in the output-logs container. If output-logs doesn't exist, Azure Functions will create it.
• Stream inputBlob: This parameter receives the content of the triggered blob.
• string name: This parameter receives the name of the blob that triggered the function.

4. Run the Function Locally

Ensure your Azure Storage Emulator is running or that your local.settings.json is configured with a valid connection string.

Run your function project from the root directory:

func start

The Azure Functions host will start and listen for triggers.

5. Test the Function

Go to your Azure Storage account in the Azure portal, navigate to the input-images container, and upload a small text file (e.g., my-test-file.txt). You can also use tools like Azure Storage Explorer.

Check the output in your terminal where func start is running. You should see log messages indicating that the blob was processed.

Now, navigate to the output-logs container in your storage account. You should find a new blob named my-test-file.txt containing the processing result message.