Introduction
Imagine a photo‑sharing app that must generate thumbnails for millions of uploads without over‑provisioning servers. In 2023, Azure reported a 30% year‑over‑year increase in event‑driven workloads, showing that developers are leaning heavily on serverless patterns to handle unpredictable spikes. This article walks through a concrete, production‑grade pipeline that uses .NET 8 Minimal APIs to accept images, Azure Event Grid to route events, and Azure Functions to perform the heavy‑lifting resize operation.
Designing the Minimal API
.NET 8 introduced a streamlined way to expose HTTP endpoints with just a few lines of code. The API acts as the entry point for image uploads, validates the payload, stores the original file in Azure Blob Storage, and then publishes an Event Grid event containing the blob URL and metadata. Because the endpoint runs in a Consumption plan, you only pay for the milliseconds the request is processed.
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddAzureClients(clientBuilder =>
clientBuilder.AddBlobServiceClient(builder.Configuration["BlobConnectionString"]));
var app = builder.Build();
app.MapPost("/upload", async (HttpRequest request, BlobServiceClient blobClient) =>
{
var container = blobClient.GetBlobContainerClient("images");
await container.CreateIfNotExistsAsync();
var file = request.Form.Files[0];
var blob = container.GetBlobClient(Guid.NewGuid()+"-"+file.FileName);
await blob.UploadAsync(file.OpenReadStream());
// Publish Event Grid event
var eventGridClient = new EventGridPublisherClient(
new Uri(builder.Configuration["EventGridTopicEndpoint"]),
new AzureKeyCredential(builder.Configuration["EventGridTopicKey"])));
var egEvent = new EventGridEvent("ImageUploaded", "ImageProcessing", "1.0",
new { Url = blob.Uri.ToString(), FileName = file.FileName });
await eventGridClient.SendEventAsync(egEvent);
return Results.Accepted();
});
app.Run();The code demonstrates three best practices: (1) use dependency injection for Azure SDK clients, (2) store files with a GUID prefix to avoid name collisions, and (3) keep the HTTP response lightweight by returning 202 Accepted after the event is queued.
Publishing Events with Azure Event Grid
Event Grid acts as a highly available, low‑latency router. By defining a custom topic named ImageProcessingTopic, you can route events to multiple handlers—future analytics, moderation services, or the thumbnail function shown later. The event schema above follows the CloudEvents 1.0 format, which Azure natively understands, so you avoid custom parsing logic downstream.
When you create the topic, enable the system topic for the storage account. This auto‑generates events for blob creation, but the explicit publish from the Minimal API gives you control over the payload and allows you to include additional fields such as user ID or priority flag.
Azure Functions as Event Handlers
The thumbnail generator is implemented as an Event Grid‑triggered Azure Function written in .NET 8. The function receives the event, downloads the original image, resizes it using the SixLabors.ImageSharp library, and writes the thumbnail back to a separate container called thumbnails. Because Functions run in a Consumption plan, scaling is automatic and you stay within a sub‑cent per million executions cost model.
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Azure.Storage.Blobs;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
public class ThumbnailFunction
{
private readonly BlobServiceClient _blobService;
public ThumbnailFunction(BlobServiceClient blobService) => _blobService = blobService;
[Function("GenerateThumbnail")]
public async Task Run([EventGridTrigger] EventGridEvent eventGridEvent)
{
var data = eventGridEvent.Data.ToObjectFromJson<dynamic>();
var sourceUrl = (string)data.Url;
var blobClient = new BlobClient(new Uri(sourceUrl), _blobService.Credential);
var download = await blobClient.DownloadAsync();
using var image = await Image.LoadAsync(download.Value.Content);
image.Mutate(x => x.Resize(new ResizeOptions { Size = new Size(200, 200), Mode = ResizeMode.Max }));
var thumbContainer = _blobService.GetBlobContainerClient("thumbnails");
await thumbContainer.CreateIfNotExistsAsync();
var thumbBlob = thumbContainer.GetBlobClient(Path.GetFileName(sourceUrl));
await using var ms = new MemoryStream();
await image.SaveAsJpegAsync(ms);
ms.Position = 0;
await thumbBlob.UploadAsync(ms, overwrite:true);
}
}
Key implementation notes: (1) the function uses dependency injection for the BlobServiceClient, mirroring the Minimal API setup; (2) ImageSharp works cross‑platform and does not require native binaries; (3) the thumbnail is stored with the same file name, simplifying lookup logic for the front‑end.
Deploying Serverless End‑to‑End
Deploy the Minimal API and the Function to Azure using the Azure CLI. First, create a resource group, then a storage account, an Event Grid topic, and finally the two apps. The following Bash snippet illustrates the sequence:
az group create --name img-pipeline-rg --location eastus
az storage account create --name imgpipelineprod --resource-group img-pipeline-rg --sku Standard_LRS
az eventgrid topic create --resource-group img-pipeline-rg --name ImageProcessingTopic --location eastus
az functionapp create --resource-group img-pipeline-rg --consumption-plan-location eastus \
--runtime dotnet --functions-version 4 --name img-thumbnail-func --storage-account imgpipelineprod
az webapp create --resource-group img-pipeline-rg --plan AppServicePlan --name img-upload-api \
--runtime "DOTNET|8.0" --deployment-local-git
After deployment, configure the Minimal API’s appsettings.json with the Blob connection string, Event Grid endpoint, and key. The Function automatically subscribes to the topic when you add an Event Grid subscription via the portal or CLI.
Monitoring and Cost Considerations
Azure Monitor provides built-in metrics for both the API App Service and the Function App. Set up alerts for 5xx response rates on the API and for function execution time exceeding 2 seconds, which could indicate a need to increase the memory allocation. Cost‑wise, a typical workload of 100,000 images per month (average 1 MB each) results in roughly 0.5 GB of storage, 100,000 Event Grid events (free up to 100,000 per month), and about 150 seconds of total function execution—well within the free tier for most developers.
Conclusion
By combining .NET 8 Minimal APIs, Azure Event Grid, and Azure Functions, you can build a truly serverless image processing pipeline that scales from a handful of daily uploads to millions without a single server to manage. The pattern separates concerns—ingestion, routing, and processing—while leveraging Azure’s pay‑as‑you‑go pricing model. Start with the code snippets above, adjust the resize dimensions to match your UI, and you’ll have a production‑ready solution in under an hour.
Author: Mahmut Sarıkaya — sarikayadev.com
Sources
Microsoft Docs – Azure Event Grid documentation; Microsoft Docs – Azure Functions developer guide; SixLabors ImageSharp official documentation.
