Serverless Patterns on Azure

Serverless architectures follow established patterns that solve common design challenges. These patterns combine Azure Functions, Logic Apps, Event Grid, API Management, and other services into proven solutions for building scalable, reliable, and maintainable applications. This lesson covers the most important serverless patterns with practical Azure implementations.

---

Pattern 1: API Backend

The most common serverless pattern — Azure Functions serving as the backend for a web or mobile application, fronted by API Management.

Architecture

Client → APIM → Azure Functions → Cosmos DB
                                 → Blob Storage
                                 → Service Bus (async operations)

Implementation

• APIM handles authentication (JWT validation), rate limiting, and CORS
• Azure Functions implement the business logic as HTTP-triggered functions
• Cosmos DB (serverless mode) stores application data
• Static Web Apps serves the frontend (React, Angular, Vue)

Key Decisions

• Use APIM Consumption tier for cost efficiency
• Use Cosmos DB serverless capacity mode for variable traffic
• Group related functions in a single function app
• Use separate function apps for distinct bounded contexts

---

Pattern 2: Event-Driven Processing

Decouple producers and consumers using events and queues.

Architecture

Producer → Event Grid / Service Bus → Azure Functions → Database
                                    → Azure Functions → Notification
                                    → Azure Functions → Analytics

Example: Order Processing

1. Order API (HTTP-triggered function) receives the order
2. Order API publishes an "OrderPlaced" event to Event Grid
3. Payment Function subscribes to "OrderPlaced" and processes payment
4. Inventory Function subscribes to "OrderPlaced" and reserves stock
5. Notification Function subscribes to "PaymentCompleted" and emails the customer

When to Use Events vs Messages

Use Case	Service
"Something happened" notification	Event Grid
"Process this" command with guaranteed delivery	Service Bus
High-volume telemetry stream	Event Hubs
Simple async task queue	Queue Storage

---

Pattern 3: File Processing Pipeline

Triggered by file uploads to Blob Storage, processing files through multiple stages.

Architecture

Upload → Blob Storage → Event Grid → Function: Validate
                                    → Function: Transform
                                    → Function: Store metadata
                                    → Cosmos DB / SQL

Example: Image Processing

1. User uploads an image to a Blob Storage container
2. Event Grid fires a BlobCreated event
3. Thumbnail Function generates resized versions
4. Metadata Function extracts EXIF data and stores it in Cosmos DB
5. Moderation Function calls Azure AI Content Safety to check for inappropriate content
6. Notification Function notifies the user when processing is complete

Best Practices

• Use Event Grid triggers (not Blob triggers) for real-time processing
• Store processed files in a separate output container
• Use Durable Functions fan-out/fan-in if multiple processing steps depend on each other
• Implement idempotency — the same blob event may be delivered more than once

---

Pattern 4: Scheduled Operations

Timer-triggered functions for recurring tasks.

Common Use Cases

// Daily data cleanup
app.timer('dailyCleanup', {
    schedule: '0 0 2 * * *',    // 2:00 AM UTC daily
    handler: async (timer, context) => {
        // Delete records older than 90 days
    }
});

// Hourly health checks
app.timer('healthCheck', {
    schedule: '0 0 * * * *',    // Every hour
    handler: async (timer, context) => {
        // Check external service health
        // Alert if degraded
    }
});

// Monthly report generation
app.timer('monthlyReport', {
    schedule: '0 0 8 1 * *',    // 1st of each month at 8:00 AM
    handler: async (timer, context) => {
        // Generate and email monthly reports
    }
});

Considerations

• Timer functions run on a single instance — they do not scale out
• Use isPastDue to detect if a scheduled execution was missed
• For jobs that take longer than 10 minutes (Consumption plan), use Durable Functions
• Store the timer state externally if you need to track execution history

---

Pattern 5: Backend for Frontend (BFF)

Create tailored API layers for different client types.

Architecture