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/json" ) else: return func.HttpResponse( json.dumps({"message": "Hello, World!"}), mimetype="application/json" ) except Exception as e: logging.error(f"Error processing request: {str(e)}") return func.HttpResponse( json.dumps({"error": "Internal server error"}), status_code=500, mimetype="application/json" )

@app.timer_trigger(schedule="0 /5 *", arg_name="myTimer") def timer_trigger(myTimer: func.TimerRequest) -> None: logging.info("Timer trigger executed")

@app.blob_trigger(arg_name="myblob", path="samples-workitems/{name}", connection="AzureWebJobsStorage") def blob_trigger(myblob: func.InputStream): logging.info(f"Blob trigger: {myblob.name}, Size: {myblob.length} bytes")

@app.queue_trigger(arg_name="msg", queue_name="myqueue", connection="AzureWebJobsStorage") def queue_trigger(msg: func.QueueMessage) -> None: logging.info(f"Queue message: {msg.get_body().decode('utf-8')}")

Notes

• v2 model uses decorators, no function.json files
• Python runs out-of-process (always isolated)
• Linux-based hosting required for Python
• Async functions supported

Durable Functions - Function Chaining

Sequential execution with state persistence

When to use: Need sequential workflow with automatic retry

Template

// C# Isolated Worker - Function Chaining using Microsoft.Azure.Functions.Worker; using Microsoft.DurableTask; using Microsoft.DurableTask.Client;

public class OrderWorkflow { [Function("OrderOrchestrator")] public static async Task<OrderResult> RunOrchestrator( [OrchestrationTrigger] TaskOrchestrationContext context) { var order = context.GetInput<Order>();

// Functions execute sequentially, state persisted between each var validated = await context.CallActivityAsync<ValidatedOrder>( "ValidateOrder", order);

var payment = await context.CallActivityAsync<PaymentResult>( "ProcessPayment", validated);

var shipped = await context.CallActivityAsync<ShippingResult>( "ShipOrder", new ShipRequest { Order = validated, Payment = payment });

var notification = await context.CallActivityAsync<bool>( "SendNotification", shipped);

return new OrderResult { OrderId = order.Id, Status = "Completed", TrackingNumber = shipped.TrackingNumber }; }

[Function("ValidateOrder")] public static async Task<ValidatedOrder> ValidateOrder( [ActivityTrigger] Order order, FunctionContext context) { var logger = context.GetLogger<OrderWorkflow>(); logger.LogInformation("Validating order {OrderId}", order.Id);

// Validation logic... return new ValidatedOrder { / ... / }; }

[Function("ProcessPayment")] public static async Task