Azure functions

Azure Functions

Expert patterns for Azure Functions development including isolated worker model, Durable Functions orchestration, cold start optimization, and production patterns. Covers .NET, Python, and Node.js programming models.

Patterns

Isolated Worker Model (.NET)

Modern .NET execution model with process isolation

When to use: Building new .NET Azure Functions apps

Template

// Program.cs - Isolated Worker Model using Microsoft.Azure.Functions.Worker; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting;

var host = new HostBuilder() .ConfigureFunctionsWorkerDefaults() .ConfigureServices(services => { // Add Application Insights services.AddApplicationInsightsTelemetryWorkerService(); services.ConfigureFunctionsApplicationInsights();

    // Add HttpClientFactory (prevents socket exhaustion)
    services.AddHttpClient();

    // Add your services
    services.AddSingleton<IMyService, MyService>();
})
.Build();

host.Run();

// HttpTriggerFunction.cs using Microsoft.Azure.Functions.Worker; using Microsoft.Azure.Functions.Worker.Http; using Microsoft.Extensions.Logging;

public class HttpTriggerFunction { private readonly ILogger<HttpTriggerFunction> _logger; private readonly IMyService _service;

public HttpTriggerFunction(
    ILogger<HttpTriggerFunction> logger,
    IMyService service)
{
    _logger = logger;
    _service = service;
}

[Function("HttpTrigger")]
public async Task<HttpResponseData> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req)
{
    _logger.LogInformation("Processing request");

    try
    {
        var result = await _service.ProcessAsync(req);

        var response = req.CreateResponse(HttpStatusCode.OK);
        await response.WriteAsJsonAsync(result);
        return response;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error processing request");
        var response = req.CreateResponse(HttpStatusCode.InternalServerError);
        await response.WriteAsJsonAsync(new { error = "Internal server error" });
        return response;
    }
}

}

Notes

• In-process model deprecated November 2026
• Isolated worker supports .NET 8, 9, 10, and .NET Framework
• Full dependency injection support
• Custom middleware support

Node.js v4 Programming Model

Modern code-centric approach for TypeScript/JavaScript

When to use: Building Node.js Azure Functions

Template

// src/functions/httpTrigger.ts import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

export async function httpTrigger( request: HttpRequest, context: InvocationContext ): Promise<HttpResponseInit> { context.log(Http function processed request for url "${request.url}");

try { const name = request.query.get("name") || (await request.text()) || "world";

return {
  status: 200,
  jsonBody: { message: `Hello, ${name}!` }
};

} catch (error) { context.error("Error processing request:", error); return { status: 500, jsonBody: { error: "Internal server error" } }; } }

// Register function with app object app.http("httpTrigger", { methods: ["GET", "POST"], authLevel: "function", handler: httpTrigger });

// Timer trigger example app.timer("timerTrigger", { schedule: "0 */5 * * * *", // Every 5 minutes handler: async (myTimer, context) => { context.log("Timer function executed at:", new Date().toISOString()); } });

// Blob trigger example app.storageBlob("blobTrigger", { path: "samples-workitems/{name}", connection: "AzureWebJobsStorage", handler: async (blob, context) => { context.log(Blob trigger processing: ${context.triggerMetadata.name}); context.log(Blob size: ${blob.length} bytes); } });

Notes

• v4 model is code-centric, no function.json files
• Uses app object similar to Express.js
• TypeScript first-class support
• All triggers registered in code

Python v2 Programming Model

Decorator-based approach for Python functions

When to use: Building Python Azure Functions

Template

function_app.py

import azure.functions as func import logging import json

app = func.FunctionApp(http_auth_level=func.AuthLevel.FUNCTION)

@app.route(route="hello", methods=["GET", "POST"]) async def http_trigger(req: func.HttpRequest) -> func.HttpResponse: logging.info("Python HTTP trigger function processed a request.")

try:
    name = req.params.get("name")
    if not name:
        try:
            req_body = req.get_json()
            name = req_body.get("name")
        except ValueError:
            pass

    if name:
        return func.HttpResponse(
            json.dumps({"message": f"Hello, {name}!"}),
            mimetype="application/jso