1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

Decision Framework for Azure Functions Hosting
 
START
  │
  ├── Need VNet connectivity?
  │     ├── Yes → Premium or Dedicated
  │     └── No → Continue
  │
  ├── Can tolerate cold starts?
  │     ├── Yes → Consumption (most cost-effective)
  │     └── No → Premium (pre-warmed) or Dedicated
  │
  ├── Function runs > 10 minutes?
  │     ├── Yes → Premium (60 min) or Dedicated (unlimited)
  │     └── No → Any plan
  │
  ├── Traffic pattern?
  │     ├── Sporadic/Unpredictable → Consumption
  │     ├── Steady with spikes → Premium
  │     └── Constant high volume → Dedicated (may be cheaper)
  │
  ├── Existing App Service investment?
  │     ├── Yes, with spare capacity → Dedicated (essentially free)
  │     └── No → Consumption or Premium
  │
  └── Kubernetes/Hybrid requirement?
        ├── Yes → KEDA on Kubernetes
        └── No → Azure-managed plan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

// Example: Comprehensive triggers and bindings in C# (Isolated Worker)
 
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
 
public class OrderProcessing
{
    private readonly ILogger<OrderProcessing> _logger;
    
    public OrderProcessing(ILogger<OrderProcessing> logger)
    {
        _logger = logger;
    }
    
    // Trigger: Azure Service Bus Queue receives order
    // Input Binding: Cosmos DB lookup for customer data
    // Output Binding: Send confirmation to another queue
    [Function("ProcessOrder")]
    [ServiceBusOutput("order-confirmations", Connection = "ServiceBusConnection")]
    public async Task<OrderConfirmation> ProcessOrder(
        [ServiceBusTrigger("new-orders", Connection = "ServiceBusConnection")]
        Order order,
        
        [CosmosDBInput(
            databaseName: "ecommerce",
            containerName: "customers",
            Connection = "CosmosDBConnection",
            Id = "{customerId}",  // Binds to order.CustomerId
            PartitionKey = "{customerId}"
        )]
        Customer customer,
        
        FunctionContext context)
    {
        _logger.LogInformation("Processing order {OrderId} for {CustomerName}", 
            order.Id, customer.Name);
        
        // Business logic here
        var confirmation = new OrderConfirmation
        {
            OrderId = order.Id,
            CustomerEmail = customer.Email,
            Status = "Processed",
            ProcessedAt = DateTime.UtcNow
        };
        
        // Return value automatically written to output binding
        return confirmation;
    }
    
    // HTTP Trigger with Blob input and Cosmos DB output
    [Function("UploadDocument")]
    public async Task<HttpResponseData> UploadDocument(
        [HttpTrigger(AuthorizationLevel.Function, "post", Route = "documents/{category}")]
        HttpRequestData req,
        string category,
        
        [BlobInput("templates/{category}/template.json", Connection = "StorageConnection")]
        string templateJson,
        
        [CosmosDBOutput("documents", "uploads", Connection = "CosmosDBConnection")]
        IAsyncCollector<Document> documents,
        
        FunctionContext context)
    {
        var template = JsonSerializer.Deserialize<Template>(templateJson);
        var requestBody = await req.ReadAsStringAsync();
        
        var document = new Document
        {
            Id = Guid.NewGuid().ToString(),
            Category = category,
            Content = requestBody,
            Template = template,
            CreatedAt = DateTime.UtcNow
        };
        
        // Output binding handles document insertion
        await documents.AddAsync(document);
        
        var response = req.CreateResponse(HttpStatusCode.Created);
        await response.WriteAsJsonAsync(document);
        return response;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// Complete order processing workflow with Durable Functions
 
using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.DurableTask.Client;
 
public class OrderWorkflow
{
    // Orchestrator: Defines the workflow logic
    [Function("ProcessOrderOrchestrator")]
    public async Task<OrderResult> ProcessOrderOrchestrator(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        var order = context.GetInput<Order>();
        var logger = context.CreateReplaySafeLogger<OrderWorkflow>();
        
        logger.LogInformation("Starting order processing for {OrderId}", order.Id);
        
        try
        {
            // Step 1: Validate inventory (with retry)
            var retryOptions = new TaskOptions(new RetryPolicy(
                maxNumberOfAttempts: 3,
                firstRetryInterval: TimeSpan.FromSeconds(1)));
            
            var inventoryResult = await context.CallActivityAsync<InventoryResult>(
                "CheckInventory", order, retryOptions);
            
            if (!inventoryResult.Available)
            {
                // Compensation: Cancel order
                await context.CallActivityAsync("CancelOrder", order);
                return new OrderResult { Success = false, Reason = "Out of stock" };
            }
            
            // Step 2: Process payment (with timeout)
            var paymentTask = context.CallActivityAsync<PaymentResult>(
                "ProcessPayment", order);
            var timeoutTask = context.CreateTimer(TimeSpan.FromMinutes(5));
            
            var winner = await Task.WhenAny(paymentTask, timeoutTask);
            
            if (winner == timeoutTask)
            {
                // Payment timed out - compensate
                await context.CallActivityAsync("ReleaseInventory", order);
                return new OrderResult { Success = false, Reason = "Payment timeout" };
            }
            
            var paymentResult = await paymentTask;
            if (!paymentResult.Success)
            {
                await context.CallActivityAsync("ReleaseInventory", order);
                return new OrderResult { Success = false, Reason = "Payment failed" };
            }
            
            // Step 3: Parallel operations - reserve and notify
            var reserveTask = context.CallActivityAsync("ReserveShipping", order);
            var notifyTask = context.CallActivityAsync("SendConfirmation", order);
            await Task.WhenAll(reserveTask, notifyTask);
            
            // Step 4: Wait for external event (shipping confirmation)
            // Suspends execution - no resource usage while waiting
            var shippingEvent = await context.WaitForExternalEvent<ShippingConfirmation>(
                "ShippingConfirmed",
                TimeSpan.FromDays(7));  // Wait up to 7 days
            
            // Step 5: Complete order
            await context.CallActivityAsync("CompleteOrder", 
                new { Order = order, Shipping = shippingEvent });
            
            return new OrderResult { Success = true, TrackingNumber = shippingEvent.TrackingNumber };
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Order processing failed");
            
            // Compensation logic
            await context.CallActivityAsync("HandleFailure", 
                new { Order = order, Error = ex.Message });
            
            throw;
        }
    }
    
    // Activity: Check inventory
    [Function("CheckInventory")]
    public async Task<InventoryResult> CheckInventory(
        [ActivityTrigger] Order order,
        FunctionContext context)
    {
        // Call inventory service
        var available = await _inventoryService.CheckAvailability(order.Items);
        return new InventoryResult { Available = available };
    }
    
    // Activity: Process payment
    [Function("ProcessPayment")]
    public async Task<PaymentResult> ProcessPayment(
        [ActivityTrigger] Order order,
        FunctionContext context)
    {
        // Call payment gateway
        return await _paymentService.Process(order);
    }
    
    // Client: Start the orchestration
    [Function("StartOrderProcessing")]
    public async Task<HttpResponseData> StartOrderProcessing(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
        [DurableClient] DurableTaskClient client,
        FunctionContext context)
    {
        var order = await req.ReadFromJsonAsync<Order>();
        
        // Start orchestration
        string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
            "ProcessOrderOrchestrator", order);
        
        // Return status URLs for polling
        var response = req.CreateResponse(HttpStatusCode.Accepted);
        await response.WriteAsJsonAsync(new
        {
            InstanceId = instanceId,
            StatusUri = $"/api/orders/{instanceId}/status"
        });
        
        return response;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

// Event Grid integration patterns
 
using Azure.Messaging.EventGrid;
using Microsoft.Azure.Functions.Worker;
 
public class EventGridPatterns
{
    // Subscribe to Azure Blob Storage events
    [Function("BlobCreatedHandler")]
    public async Task HandleBlobCreated(
        [EventGridTrigger] EventGridEvent eventGridEvent,
        FunctionContext context)
    {
        var logger = context.GetLogger<EventGridPatterns>();
        
        // Event Grid provides rich metadata
        logger.LogInformation("Event Type: {Type}", eventGridEvent.EventType);
        logger.LogInformation("Subject: {Subject}", eventGridEvent.Subject);
        
        if (eventGridEvent.EventType == "Microsoft.Storage.BlobCreated")
        {
            var blobData = eventGridEvent.Data.ToObjectFromJson<BlobCreatedData>();
            logger.LogInformation("Processing blob: {Url}", blobData.Url);
            
            // Process the new blob
            await ProcessNewBlob(blobData.Url);
        }
    }
    
    // Subscribe to custom events with filtering
    // Event Grid filter configured in function.json or host:
    // "subject": { "beginsWith": "/orders/" }
    [Function("OrderEventHandler")]
    public async Task HandleOrderEvent(
        [EventGridTrigger] EventGridEvent eventGridEvent,
        FunctionContext context)
    {
        switch (eventGridEvent.EventType)
        {
            case "Order.Created":
                await HandleOrderCreated(eventGridEvent.Data);
                break;
            case "Order.Cancelled":
                await HandleOrderCancelled(eventGridEvent.Data);
                break;
            case "Order.Shipped":
                await HandleOrderShipped(eventGridEvent.Data);
                break;
        }
    }
    
    // Publish custom events to Event Grid
    [Function("PublishOrderEvent")]
    public async Task PublishOrderEvent(
        [QueueTrigger("order-updates")] OrderUpdate update,
        FunctionContext context)
    {
        var client = new EventGridPublisherClient(
            new Uri(Environment.GetEnvironmentVariable("EVENT_GRID_TOPIC_ENDPOINT")),
            new Azure.AzureKeyCredential(Environment.GetEnvironmentVariable("EVENT_GRID_KEY"))
        );
        
        var @event = new EventGridEvent(
            subject: $"/orders/{update.OrderId}",
            eventType: $"Order.{update.Status}",
            dataVersion: "1.0",
            data: update
        );
        
        await client.SendEventAsync(@event);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

// Comprehensive observability in Azure Functions
 
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
 
public class ObservableFunction
{
    private readonly ILogger<ObservableFunction> _logger;
    private readonly TelemetryClient _telemetry;
    
    public ObservableFunction(
        ILogger<ObservableFunction> logger,
        TelemetryClient telemetry)
    {
        _logger = logger;
        _telemetry = telemetry;
    }
    
    [Function("ProcessOrder")]
    public async Task<IActionResult> ProcessOrder(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
        FunctionContext context)
    {
        // Structured logging with semantic properties
        using var scope = _logger.BeginScope(new Dictionary<string, object>
        {
            ["CorrelationId"] = context.InvocationId,
            ["Operation"] = "ProcessOrder"
        });
        
        _logger.LogInformation("Order processing started");
        
        var stopwatch = Stopwatch.StartNew();
        
        try
        {
            var order = await req.ReadFromJsonAsync<Order>();
            
            // Custom properties for filtering/analysis
            _telemetry.Context.GlobalProperties["CustomerId"] = order.CustomerId;
            _telemetry.Context.GlobalProperties["OrderValue"] = order.TotalAmount.ToString();
            
            // Track custom event
            _telemetry.TrackEvent("OrderReceived", new Dictionary<string, string>
            {
                ["OrderId"] = order.Id,
                ["ItemCount"] = order.Items.Count.ToString()
            });
            
            // Process with dependency tracking
            using (var operation = _telemetry.StartOperation<DependencyTelemetry>("ProcessPayment"))
            {
                operation.Telemetry.Type = "Payment Gateway";
                operation.Telemetry.Target = "stripe.com";
                
                var paymentResult = await _paymentService.ProcessPayment(order);
                
                operation.Telemetry.Success = paymentResult.Success;
                operation.Telemetry.ResultCode = paymentResult.Code;
            }
            
            // Track custom metrics
            _telemetry.TrackMetric("OrderProcessingDuration", stopwatch.ElapsedMilliseconds);
            _telemetry.TrackMetric("OrderValue", order.TotalAmount);
            
            _logger.LogInformation("Order {OrderId} processed successfully in {Duration}ms",
                order.Id, stopwatch.ElapsedMilliseconds);
            
            return new OkObjectResult(new { order.Id, Status = "Processed" });
        }
        catch (PaymentException ex)
        {
            // Track exception with custom properties
            _telemetry.TrackException(ex, new Dictionary<string, string>
            {
                ["ErrorCode"] = ex.ErrorCode,
                ["PaymentMethod"] = ex.PaymentMethod
            });
            
            _logger.LogError(ex, "Payment processing failed for order");
            
            return new BadRequestObjectResult(new { Error = "Payment failed" });
        }
    }
}
 
// ILogger automatically integrates with Application Insights
// Configure sampling and filtering in host.json:
/*
{
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "maxTelemetryItemsPerSecond": 20,
        "excludedTypes": "Dependency;Event"
      }
    },
    "logLevel": {
      "default": "Information",
      "Host.Results": "Error",
      "Function": "Information",
      "Host.Aggregator": "Information"
    }
  }
}
*/