Azure Functions
Complete Guide

[FunctionName("ProcessOrder")]
public static async Task Run(
    [ServiceBusTrigger("orders", Connection = "ServiceBusConn")]
    ServiceBusReceivedMessage message,
    ServiceBusMessageActions msgActions,

    // Input binding — read config from Blob
    [Blob("config/settings.json", FileAccess.Read, Connection = "StorageConn")]
    string configJson,

    // Output binding — write result to Blob
    [Blob("results/{rand-guid}.json", FileAccess.Write, Connection = "StorageConn")]
    TextWriter resultBlob,

    // Output binding — send confirmation to another queue
    [ServiceBus("confirmations", Connection = "ServiceBusConn")]
    IAsyncCollector<ServiceBusMessage> confirmQueue,

    // Output binding — upsert to Cosmos DB
    [CosmosDB("orders-db", "processed", Connection = "CosmosConn")]
    IAsyncCollector<dynamic> cosmosOutput,

    ILogger log)
{
    var order = JsonSerializer.Deserialize<Order>(message.Body.ToString());
    var config = JsonSerializer.Deserialize<Config>(configJson);

    // Write to blob
    await resultBlob.WriteAsync(JsonSerializer.Serialize(order));

    // Send confirmation
    await confirmQueue.AddAsync(new ServiceBusMessage(order.OrderId));

    // Upsert to Cosmos DB
    await cosmosOutput.AddAsync(new { id = order.OrderId, status = "processed" });

    // Complete Service Bus message
    await msgActions.CompleteMessageAsync(message);
}

// Program.cs — host setup
var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .ConfigureServices(services =>
    {
        services.AddSingleton<IOrderService, OrderService>();
        services.AddApplicationInsightsTelemetryWorkerService();
    })
    .Build();

await host.RunAsync();

// OrderFunction.cs
public class OrderFunction
{
    private readonly IOrderService _orderService;

    public OrderFunction(IOrderService orderService)
    {
        _orderService = orderService;
    }

    [Function("ProcessOrder")]
    public async Task Run(
        [ServiceBusTrigger("orders", Connection = "ServiceBusConn")]
        ServiceBusReceivedMessage message,
        ServiceBusMessageActions actions)
    {
        await _orderService.ProcessAsync(message.Body.ToString());
        await actions.CompleteMessageAsync(message);
    }
}

import azure.functions as func
import json, logging

app = func.FunctionApp()

@app.service_bus_queue_trigger(
    arg_name="msg",
    queue_name="orders",
    connection="ServiceBusConn")
def process_order(msg: func.ServiceBusMessage):
    body = msg.get_body().decode('utf-8')
    order = json.loads(body)
    logging.info(f"Processing order: {order['orderId']}")
    # Process...

@app.route(route="orders", methods=["POST"])
def create_order(req: func.HttpRequest) -> func.HttpResponse:
    body = req.get_json()
    return func.HttpResponse(
        json.dumps({"created": True, "id": "123"}),
        mimetype="application/json",
        status_code=201)

[Function("CreateOrder")]
public async Task<HttpResponseData> CreateOrder(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "orders")]
    HttpRequestData req,
    FunctionContext context)
{
    var logger = context.GetLogger<OrderFunction>();

    // Validate content type
    if (!req.Headers.TryGetValues("Content-Type", out var ct)
        || !ct.First().Contains("application/json"))
    {
        var badReq = req.CreateResponse(HttpStatusCode.BadRequest);
        await badReq.WriteAsJsonAsync(new { error = "Content-Type must be application/json" });
        return badReq;
    }

    // Deserialize body
    Order? order;
    try
    {
        order = await req.ReadFromJsonAsync<Order>();
        if (order == null) throw new JsonException("Null body");
    }
    catch (JsonException ex)
    {
        logger.LogError(ex, "Invalid request body");
        var badReq = req.CreateResponse(HttpStatusCode.BadRequest);
        await badReq.WriteAsJsonAsync(new { error = "Invalid JSON" });
        return badReq;
    }

    // Process
    var result = await _orderService.CreateAsync(order);

    // Return 201 Created
    var response = req.CreateResponse(HttpStatusCode.Created);
    response.Headers.Add("Location", $"/api/orders/{result.Id}");
    response.Headers.Add("X-Request-Id", context.InvocationId.ToString());
    await response.WriteAsJsonAsync(result);
    return response;
}

// Route: GET /api/orders/{orderId}/items/{itemId}
[Function("GetOrderItem")]
public async Task<HttpResponseData> GetOrderItem(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get",
        Route = "orders/{orderId}/items/{itemId}")]
    HttpRequestData req,
    string orderId,
    string itemId)
{
    var item = await _orderService.GetItemAsync(orderId, itemId);
    if (item == null)
    {
        return req.CreateResponse(HttpStatusCode.NotFound);
    }
    var response = req.CreateResponse(HttpStatusCode.OK);
    await response.WriteAsJsonAsync(item);
    return response;
}

[Function("DailyReport")]
public async Task Run(
    [TimerTrigger("0 0 9 * * 1-5")] TimerInfo timer,
    FunctionContext context)
{
    var logger = context.GetLogger<ReportFunction>();

    if (timer.ScheduleStatus?.Last != null)
        logger.LogInformation($"Last run: {timer.ScheduleStatus.Last}");

    if (timer.IsPastDue)
        logger.LogWarning("Timer is past due — missed schedule");

    // Run daily report logic
    var report = await _reportService.GenerateDailyAsync(DateTime.UtcNow);
    await _emailService.SendAsync("team@mycompany.com", "Daily Report", report);
}

[Function("ProcessOrder")]
public async Task Run(
    [ServiceBusTrigger("orders", Connection = "ServiceBusConn")]
    ServiceBusReceivedMessage message,
    ServiceBusMessageActions actions,
    ILogger log)
{
    try
    {
        string body = message.Body.ToString();
        var order = JsonSerializer.Deserialize<Order>(body)!;

        log.LogInformation($"Processing order {order.OrderId}");
        await _orderService.ProcessAsync(order);

        await actions.CompleteMessageAsync(message); // ✅ Success
    }
    catch (Exception ex)
    {
        log.LogError(ex, "Failed to process order");

        if (message.DeliveryCount >= 3)
        {
            await actions.DeadLetterMessageAsync(message,
                "MaxRetriesExceeded", ex.Message);
        }
        else
        {
            await actions.AbandonMessageAsync(message); // Retry
        }
    }
}

[Function("HandleBillingEvent")]
public void Run(
    [ServiceBusTrigger("order-events", "billing", Connection = "ServiceBusConn")]
    string messageBody,
    int deliveryCount,
    string messageId,
    ILogger log)
{
    log.LogInformation($"Billing event [{messageId}]: {messageBody}");
}

[Function("ProcessSessionOrder")]
public async Task Run(
    [ServiceBusTrigger("session-orders",
        IsSessionsEnabled = true,
        Connection = "ServiceBusConn")]
    ServiceBusReceivedMessage message,
    ServiceBusSessionMessageActions sessionActions)
{
    string sessionId = message.SessionId;

    // Get/set session state for ordered processing
    byte[] currentState = await sessionActions.GetSessionStateAsync();

    // Process in order...
    await sessionActions.CompleteMessageAsync(message);
    await sessionActions.SetSessionStateAsync(BinaryData.FromString("step-complete"));
}

[Function("CreateOrder")]
[ServiceBusOutput("orders", Connection = "ServiceBusConn")]
public ServiceBusMessage Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post")]
    HttpRequestData req)
{
    string body = req.ReadAsString();
    return new ServiceBusMessage(body)
    {
        ContentType = "application/json",
        Subject = "OrderCreated",
        ApplicationProperties = { ["Source"] = "API" }
    };
}

[Function("HandleDLQ")]
public void Run(
    [ServiceBusTrigger("orders/$deadletterqueue", Connection = "ServiceBusConn")]
    ServiceBusReceivedMessage dlqMsg,
    ILogger log)
{
    log.LogError("DLQ: {Id} | Reason: {Reason} | Desc: {Desc}",
        dlqMsg.MessageId,
        dlqMsg.DeadLetterReason,
        dlqMsg.DeadLetterErrorDescription);

    // Store to Blob for analysis, alert on-call team, replay etc.
}

{
  "version": "2.0",
  "extensions": {
    "serviceBus": {
      "prefetchCount": 20,
      "transportType": "amqpWebSockets",
      "messageHandlerOptions": {
        "autoComplete": false,
        "maxConcurrentCalls": 16,
        "maxAutoRenewDuration": "00:10:00"
      },
      "sessionHandlerOptions": {
        "autoComplete": false,
        "messageWaitTimeout": "00:00:30",
        "maxConcurrentSessions": 8
      }
    }
  }
}

[Function("ProcessDocument")]
public async Task Run(
    [BlobTrigger("uploads/{name}", Connection = "StorageConn")]
    Stream blobStream,
    string name,
    BlobClient blobClient,
    ILogger log)
{
    log.LogInformation($"Processing blob: {name}, Size: {blobStream.Length}");

    BlobProperties props = await blobClient.GetPropertiesAsync();
    string contentType = props.ContentType;

    // Process the blob...
    using var reader = new StreamReader(blobStream);
    string content = await reader.ReadToEndAsync();
}

[Function("TransformDocument")]
public async Task Run(
    [QueueTrigger("transform-jobs", Connection = "StorageConn")]
    string jobId,

    // Read source blob
    [BlobInput("raw/{queueTrigger}.json", Connection = "StorageConn")]
    string sourceJson,

    // Write result blob
    [BlobOutput("processed/{queueTrigger}-result.json", Connection = "StorageConn")]
    TextWriter outputBlob)
{
    var data = JsonDocument.Parse(sourceJson);
    var transformed = TransformData(data);
    await outputBlob.WriteAsync(JsonSerializer.Serialize(transformed));
}

[Function("ProcessQueueTask")]
public void Run(
    [QueueTrigger("task-queue", Connection = "StorageConn")]
    QueueMessage message,
    ILogger log)
{
    log.LogInformation($"Task: {message.MessageText}");
    log.LogInformation($"Dequeue count: {message.DequeueCount}");
}

// Write to Table Storage
[Function("LogEvent")]
[TableOutput("AuditLog", Connection = "StorageConn")]
public TableEntity Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post")]
    HttpRequestData req)
{
    return new TableEntity("2025-01", Guid.NewGuid().ToString())
    {
        ["EventType"] = "UserAction",
        ["UserId"] = req.Headers.GetValues("X-User-Id").First()
    };
}

// Read from Table Storage
[Function("GetUser")]
public async Task<HttpResponseData> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "users/{id}")]
    HttpRequestData req,
    [TableInput("Users", "Profiles", "{id}", Connection = "StorageConn")]
    UserEntity? user)
{
    if (user == null) return req.CreateResponse(HttpStatusCode.NotFound);
    var res = req.CreateResponse(HttpStatusCode.OK);
    await res.WriteAsJsonAsync(user);
    return res;
}

[Function("HandleBlobCreated")]
public void Run(
    [EventGridTrigger] CloudEvent cloudEvent,
    ILogger log)
{
    log.LogInformation($"Event type: {cloudEvent.Type}");
    log.LogInformation($"Event subject: {cloudEvent.Subject}");

    if (cloudEvent.Type == "Microsoft.Storage.BlobCreated")
    {
        var data = cloudEvent.Data?.ToObjectFromJson<StorageBlobCreatedEventData>();
        log.LogInformation($"Blob URL: {data?.Url}");
        log.LogInformation($"Content type: {data?.ContentType}");
        // Trigger downstream processing...
    }
}

[Function("PublishEvent")]
[EventGridOutput(TopicEndpointUri = "EventGridTopicUri",
    TopicKeySetting = "EventGridTopicKey")]
public EventGridEvent Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req)
{
    var body = req.ReadFromJsonAsync<OrderCreatedEvent>().Result;
    return new EventGridEvent(
        subject: $"orders/{body?.OrderId}",
        eventType: "OrderCreated",
        dataVersion: "1.0",
        data: body);
}

// Process batch of Event Hub events
[Function("ProcessTelemetry")]
public async Task Run(
    [EventHubTrigger("telemetry-hub",
        Connection = "EventHubConn",
        ConsumerGroup = "functions-consumer")]
    EventData[] events,
    ILogger log)
{
    foreach (var evt in events)
    {
        string data = Encoding.UTF8.GetString(evt.Body.ToArray());
        log.LogInformation($"Event: {data}");
        log.LogInformation($"Partition: {evt.PartitionKey}");
        log.LogInformation($"Offset: {evt.Offset}");
        log.LogInformation($"Sequence: {evt.SequenceNumber}");

        // Process telemetry...
    }
}

// host.json — Event Hub batch settings
// "eventHub": {
//   "maxBatchSize": 64,
//   "prefetchCount": 256,
//   "batchCheckpointFrequency": 5
// }

[Function("ForwardToEventHub")]
[EventHubOutput("output-hub", Connection = "EventHubConn")]
public string Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post")]
    HttpRequestData req)
{
    return req.ReadAsString();
}

// Orchestrator — fan-out to parallel activities, fan-in results
[Function("OrderOrchestrator")]
public static async Task<List<string>> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var order = context.GetInput<Order>();

    // Fan-out — start all tasks in parallel
    var tasks = new List<Task<string>>
    {
        context.CallActivityAsync<string>("ValidatePayment",  order),
        context.CallActivityAsync<string>("CheckInventory",   order),
        context.CallActivityAsync<string>("CalculateShipping", order)
    };

    // Fan-in — wait for ALL to complete
    var results = await Task.WhenAll(tasks);

    // Continue with all results available
    await context.CallActivityAsync("FinalizeOrder",
        new { Order = order, Results = results });

    return results.ToList();
}

// Activity Function
[Function("ValidatePayment")]
public static async Task<string> ValidatePayment(
    [ActivityTrigger] Order order, ILogger log)
{
    log.LogInformation($"Validating payment for order {order.OrderId}");
    var result = await _paymentService.ValidateAsync(order);
    return result.Status;
}

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

    // Send approval request email
    await context.CallActivityAsync("SendApprovalEmail", order);

    // Wait for external event (up to 48 hours)
    using var timeoutCts = new CancellationTokenSource();
    var deadline = context.CurrentUtcDateTime.AddHours(48);
    var approvalTask = context.WaitForExternalEvent<bool>("ApprovalResult");
    var timeoutTask = context.CreateTimer(deadline, timeoutCts.Token);

    var winner = await Task.WhenAny(approvalTask, timeoutTask);

    if (winner == approvalTask && approvalTask.Result)
    {
        timeoutCts.Cancel();
        await context.CallActivityAsync("ProcessApprovedOrder", order);
    }
    else
    {
        await context.CallActivityAsync("NotifyTimeout", order);
    }
}

{
  "Call_function": {
    "type": "Function",
    "inputs": {
      "function": {
        "id": "/subscriptions/<sub>/resourceGroups/<rg>/providers/Microsoft.Web/sites/<funcApp>/functions/ProcessData"
      },
      "method": "POST",
      "body": "@triggerBody()"
    }
  }
}

// Function triggers a Logic App HTTP workflow
[Function("TriggerApproval")]
public async Task Run(
    [ServiceBusTrigger("high-value-orders", Connection = "ServiceBusConn")]
    string orderJson)
{
    using var http = new HttpClient();

    // Logic App HTTP trigger URL stored in Key Vault / App Settings
    var logicAppUrl = Environment.GetEnvironmentVariable("APPROVAL_LOGIC_APP_URL");

    var response = await http.PostAsync(
        logicAppUrl,
        new StringContent(orderJson, Encoding.UTF8, "application/json"));

    response.EnsureSuccessStatusCode();
}

# Enable Entra ID auth on Function App
az functionapp auth update \
  --name myFuncApp \
  --resource-group myRG \
  --enabled true \
  --action LoginWithAzureActiveDirectory

# Configure Entra ID provider
az functionapp auth microsoft update \
  --name myFuncApp \
  --resource-group myRG \
  --client-id <entra-app-client-id> \
  --allowed-audiences api://my-func-app-id

// Enable System Assigned Identity in Portal or CLI
// az functionapp identity assign --name myFuncApp --resource-group myRG

// In function code — no connection strings needed
var credential = new DefaultAzureCredential();

// Access Blob Storage
var blobClient = new BlobServiceClient(
    new Uri("https://mystorageaccount.blob.core.windows.net"), credential);

// Access Service Bus
var sbClient = new ServiceBusClient(
    "mynamespace.servicebus.windows.net", credential);

// Access Key Vault
var kvClient = new SecretClient(
    new Uri("https://mykeyvault.vault.azure.net"), credential);

var secret = await kvClient.GetSecretAsync("my-secret");

# Reference Key Vault secret in App Settings
az functionapp config appsettings set \
  --name myFuncApp \
  --resource-group myRG \
  --settings "DB_CONNECTION=@Microsoft.KeyVault(SecretUri=https://myKeyVault.vault.azure.net/secrets/db-conn)"

# Function reads it as a normal environment variable
string connStr = Environment.GetEnvironmentVariable("DB_CONNECTION")!;

# Add VNet integration for outbound traffic
az functionapp vnet-integration add \
  --name myFuncApp \
  --resource-group myRG \
  --vnet myVNet \
  --subnet myFunctionSubnet

# Route ALL outbound traffic through VNet (access private resources)
az functionapp config appsettings set \
  --name myFuncApp --resource-group myRG \
  --settings WEBSITE_VNET_ROUTE_ALL=1

# Create private endpoint for Function App (inbound)
az network private-endpoint create \
  --name myFuncPrivateEndpoint \
  --resource-group myRG \
  --vnet-name myVNet \
  --subnet myPESubnet \
  --private-connection-resource-id $(az functionapp show --name myFuncApp --resource-group myRG --query id -o tsv) \
  --group-ids sites \
  --connection-name myFuncConn

{
  "version": "2.0",
  "functionTimeout": "00:10:00",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    },
    "logLevel": {
      "default": "Information",
      "Host.Results": "Error",
      "Function": "Information"
    }
  },
  "extensions": {
    "serviceBus": {
      "prefetchCount": 20,
      "messageHandlerOptions": {
        "autoComplete": false,
        "maxConcurrentCalls": 16
      }
    },
    "http": {
      "routePrefix": "api",
      "maxConcurrentRequests": 100,
      "maxOutstandingRequests": 200
    },
    "queues": {
      "maxPollingInterval": "00:00:02",
      "visibilityTimeout": "00:00:30",
      "maxDequeueCount": 5,
      "batchSize": 16
    }
  }
}

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
    "ServiceBusConn": "Endpoint=sb://...",
    "StorageConn": "DefaultEndpointsProtocol=https;AccountName=...",

    // For Managed Identity (no connection string!)
    "ServiceBusConn__fullyQualifiedNamespace": "<ns>.servicebus.windows.net",
    "StorageConn__accountName": "mystorageaccount",
    "CosmosConn__accountEndpoint": "https://myaccount.documents.azure.com:443/"
  }
}

// Structured logging — queryable in App Insights
_logger.LogInformation(
    "Processing order {OrderId} for customer {CustomerId} amount {Amount:C}",
    order.OrderId, order.CustomerId, order.Amount);

// Custom metric
_telemetryClient.TrackMetric("OrderAmount", order.Amount,
    new Dictionary<string, string> { ["Region"] = order.Region });

// Custom event
_telemetryClient.TrackEvent("OrderProcessed",
    new Dictionary<string, string>
    {
        ["OrderId"] = order.OrderId,
        ["ProcessingTimeMs"] = stopwatch.ElapsedMilliseconds.ToString()
    });

// Failed function invocations in last hour
requests
| where success == false
| where timestamp > ago(1h)
| where cloud_RoleName == "my-function-app"
| summarize count() by name, resultCode
| order by count_ desc

// P99 latency by function
requests
| where timestamp > ago(24h)
| where cloud_RoleName == "my-function-app"
| summarize p99 = percentile(duration, 99) by name
| order by p99 desc

name: Deploy Azure Functions
on:
  push:
    branches: [main]

jobs:
  build-deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3

    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '8.0.x'

    - name: Build
      run: dotnet publish src/MyFunctionApp/MyFunctionApp.csproj \
        --configuration Release --output ./publish

    - name: Login to Azure
      uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: Deploy to Function App
      uses: Azure/functions-action@v1
      with:
        app-name: myFuncApp
        package: ./publish
        respect-funcignore: true

# Deploy to staging slot
az functionapp deployment source config-zip \
  --name myFuncApp \
  --resource-group myRG \
  --slot staging \
  --src ./publish.zip

# Run smoke tests against staging slot
# https://myFuncApp-staging.azurewebsites.net/api/...

# Swap staging → production (zero downtime)
az functionapp deployment slot swap \
  --name myFuncApp \
  --resource-group myRG \
  --slot staging \
  --target-slot production

// Program.cs — register as singletons via DI
var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .ConfigureServices(services =>
    {
        // Registered once, reused across all invocations
        services.AddSingleton(_ =>
            new ServiceBusClient(
                "<namespace>.servicebus.windows.net",
                new DefaultAzureCredential()));

        services.AddSingleton(_ =>
            new BlobServiceClient(
                new Uri("https://account.blob.core.windows.net"),
                new DefaultAzureCredential()));

        services.AddHttpClient("backend", c =>
        {
            c.BaseAddress = new Uri("https://api.mybackend.com");
            c.Timeout = TimeSpan.FromSeconds(30);
        });
    })
    .Build();