Azure Functions - Serverless Computing on Azure

Azure Functions is a serverless compute solution from Microsoft Azure that enables developers to run event-driven code without managing infrastructure. The service scales automatically based on load and you only pay for actual execution time.

What is Azure Functions?

Azure Functions is Microsoft’s answer to the growing demand for serverless computing. The service enables running code in response to events without explicitly provisioning or managing servers. Developers can focus entirely on their business logic while Azure manages the complete infrastructure.

The platform supports a variety of programming languages (C#, Java, JavaScript, TypeScript, Python, PowerShell) and offers native integration with over 40 Azure services through triggers and bindings. This means: Write code, deploy, and Azure handles scaling, high availability, and operations.

Azure Functions is particularly interesting for companies already working in the Microsoft ecosystem or operating hybrid cloud scenarios. The service meets all relevant compliance standards (ISO 27001, SOC 2, GDPR) and is available in German and European Azure regions.

A key differentiator compared to competitors: Azure Functions offers Durable Functions, a unique extension for stateful workflows that enables complex orchestrations with automatic state management. This makes the service ideal for long-running processes, human-interaction workflows, and AI agent orchestration.

Hosting Plans Compared

Azure Functions offers four different hosting options that differ in scaling, costs, and features:

Recommendation: For new production applications, you should choose the Flex Consumption Plan (GA since 2024) or Premium Plan. The classic Consumption plan is only recommended for development/testing as the Linux Consumption plan will be retired in September 2028.

Durable Functions for Workflows

Durable Functions is an extension of Azure Functions that enables stateful workflows in a serverless environment. Unlike classic functions that are stateless, Durable Functions allow:

• Stateful orchestrations: Complex multi-step workflows with automatic state management
• Automatic checkpointing: On crashes, resume from the last successful step
• Built-in retry logic: Fault tolerance without manual code
• Human-interaction patterns: Workflows with timeouts and external events (e.g., approval processes)
• Fan-out/fan-in: Parallel execution of multiple tasks with result aggregation

Typical Durable Functions Patterns

1. Function Chaining: Sequential function execution

var x = await context.CallActivityAsync<object>("F1", null);
var y = await context.CallActivityAsync<object>("F2", x);
return await context.CallActivityAsync<object>("F3", y);

2. Fan-out/Fan-in: Parallel processing with aggregation

var tasks = new List<Task<int>>();
foreach (var item in workBatch) {
    tasks.Add(context.CallActivityAsync<int>("ProcessItem", item));
}
await Task.WhenAll(tasks);
int sum = tasks.Sum(t => t.Result);

3. Async HTTP APIs: Long-running operations with status polling

4. Monitoring: Recurring checks with flexible intervals

5. Human Interaction: Approval workflows with timeouts and escalation

Durable Functions is ideal for AI agents, data pipelines, approval workflows, and all scenarios that go beyond simple request-response patterns.

Typical Use Cases

Azure Functions covers a broad spectrum of use cases:

1. HTTP APIs and Webhooks

Create RESTful APIs without server management. Ideal for backend-for-frontend (BFF) patterns, microservices architectures, or as API gateway complement.

Example: Validation of payment webhooks from Stripe/PayPal, user registration APIs, OAuth callback handlers.

2. Event Processing and Integration

Process events from Azure services (Event Hub, Service Bus, Storage Queues) or external systems in real-time.

Example: Order workflows in e-commerce, log aggregation, IoT telemetry processing.

3. Scheduled Tasks (Cron Jobs)

Execute periodic tasks without dedicated servers. Timer trigger supports cron syntax.

Example: Nightly database backups, report generation, data synchronization between systems.

4. File Processing

React automatically to file uploads in Azure Blob Storage.

Example: Image resizing on upload, PDF generation, video transcoding, document OCR.

5. Real-time Stream Processing

Process continuous data streams with high throughput.

Example: Clickstream analysis, sensor data aggregation, real-time fraud detection.

6. AI and Machine Learning Inference

Integrate Azure OpenAI, Azure AI Foundry, or custom ML models for AI workloads.

Example: RAG chatbots, text classification, sentiment analysis, AI agents with Durable Functions.

7. Serverless Workflows

Orchestrate complex business processes with Durable Functions.

Example: Order fulfillment workflows, onboarding processes with approval steps, multi-step ETL pipelines.

Best Practices

1. Choose the Right Hosting Plan

• Development/Testing: Consumption plan (use Free Tier)
• Production (Standard): Flex Consumption or Premium plan
• Latency-critical: Premium plan with always-ready instances
• Existing App Service: Dedicated plan for resource optimization

2. Avoid Long-Running Functions

• Consumption: Max 10 minutes execution time (timeout)
• For long processes: Use Durable Functions with checkpointing
• Split large tasks into smaller activity functions

3. Use Asynchronous Code

// Good: Use async/await
public static async Task Run([HttpTrigger] HttpRequest req)
{
    var data = await GetDataAsync();
    return new OkObjectResult(data);
}

// Bad: Blocking calls
public static Task Run([HttpTrigger] HttpRequest req)
{
    var data = GetData(); // Blocks thread!
    return Task.FromResult(new OkObjectResult(data));
}

4. Optimize Storage Configuration

• Use separate storage accounts for production functions
• Storage account in same region as function app (latency)
• For Event Hub triggers: Don’t use Data Lake Storage accounts

5. Implement Connection Pooling

Avoid socket exhaustion by reusing HTTP clients:

private static readonly HttpClient httpClient = new HttpClient();

public static async Task Run([HttpTrigger] HttpRequest req)
{
    var response = await httpClient.GetAsync("https://api.example.com");
}

6. Monitoring and Observability

• Enable Application Insights (enabled by default)
• Use structured logging for better analysis
• Configure custom metrics for business KPIs
• Set alerts for error rates and performance degradation

7. Deployment Best Practices

• Use “Run from Package” for faster deployments
• Use deployment slots for zero-downtime deployments
• CI/CD with GitHub Actions or Azure DevOps
• Infrastructure as Code with Bicep/Terraform

8. Security

• Use Managed Identities instead of connection strings where possible
• Function keys for HTTP triggers (or Microsoft Entra ID)
• VNET integration for sensitive workloads (Premium/Dedicated)
• Private endpoints for storage and databases

9. Cost Optimization

• Set functionAppScaleLimit to avoid unlimited scaling
• Use always-ready instances strategically (Premium)
• Monitor execution counts and memory consumption
• Disable unused functions

10. Error Handling and Resilience

• Implement retry policies for transient failures
• Use dead-letter queues for failed messages
• Use circuit breaker pattern for external dependencies
• Test failure scenarios (chaos engineering)

Azure Functions vs. Alternatives

When choosing a serverless solution, the question of alternatives often arises:

AWS Lambda: Market leader with largest ecosystem, but more complex IAM management Google Cloud Functions: Good integration with GCP, but smaller feature set Google Cloud Run: Container-based, more flexibility but less managed

Azure Functions excels particularly in:

• Companies with Microsoft stack (Active Directory, Office 365, Dynamics)
• Hybrid cloud scenarios (Azure Arc)
• Durable Functions for stateful workflows (unique differentiator)
• Integration with Azure ecosystem (Cosmos DB, Event Hub, etc.)

Migration and Linux Consumption Plan Retirement

Important: The Azure Functions Linux Consumption plan will be retired in September 2028. Microsoft recommends migration to:

1. Flex Consumption Plan (recommended for most workloads)
2. Premium Plan (for VNET integration and always-ready instances)
3. Container Apps (for container-based deployments)

Migration should be completed by Q2 2028 at the latest. Windows Consumption plan is not affected.

Frequently Asked Questions

What does Azure Functions cost?

Azure Functions offers a usage-based pricing model:

• Consumption: First 1 million executions + 400,000 GB-s free per month
• Premium: From approx. 150 EUR/month for EP1 plan (1 vCore, 3.5 GB RAM)
• Dedicated: Depends on App Service plan (from approx. 60 EUR/month for B1)

Calculate detailed costs in the Azure Pricing Calculator.

Is Azure Functions GDPR compliant?

Yes, Azure Functions can be operated in GDPR compliance when choosing European regions (e.g., Germany West Central, West Europe). Microsoft offers Data Protection Addendums (DPA) and meets ISO 27001, SOC 2, and other standards.

How does Azure Functions integrate with other Azure services?

Azure Functions offers bindings for over 40 services: Cosmos DB, Event Hub, Service Bus, Blob Storage, SQL Database, SignalR, SendGrid, etc. Bindings eliminate boilerplate code for authentication and connection management.

What SLAs does Azure Functions offer?

• Consumption Plan: No SLA (best effort)
• Flex Consumption Plan: 99.95% SLA
• Premium Plan: 99.95% SLA
• Dedicated Plan: 99.95% SLA (depends on App Service plan)

Can I use Azure Functions in hybrid cloud scenarios?

Yes, via Azure Arc, functions can also be operated on-premises or in other clouds. Additionally, Premium and Dedicated plans support VNET integration for hybrid connectivity via ExpressRoute.

Integration with innFactory

As a Microsoft Solutions Partner, innFactory supports you with:

• Architecture Consulting: Choosing the right hosting plan and patterns
• Migration: From monolithic apps or other cloud providers
• Development: Development of Functions-based solutions
• DevOps: CI/CD, Infrastructure as Code, monitoring setup
• Cost Optimization: Analysis and optimization of function costs
• AI Integration: Azure OpenAI, Azure AI Foundry, custom ML models

Contact us for a non-binding consultation on Azure Functions and serverless architectures.