Azure Functions

1. What are Azure Functions?

• Azure Functions is a serverless compute service that lets you run event-driven code without managing infrastructure.

• Supports running code in response to a variety of events: HTTP requests, timer schedules, queues, blob storage events, Event Hub, Service Bus messages, and more.

• Focus is on “Functions as a Service” (FaaS): you write only the function logic, Azure handles provisioning, scalability, and reliability automatically.

2. Core Concepts & Architecture

3. Development (Languages & Tooling)

• Languages Supported: C#, JavaScript (Node.js), Python, Java, PowerShell, TypeScript, custom handlers (Go, Rust, etc.).

• Develop Locally: Use Visual Studio, VS Code (Azure Functions extension), or the Azure Functions Core Tools (CLI).

• Project Structure: Each function has a function.json file defining its trigger and bindings, plus the code file.

Example: HTTP-triggered C# Function

using System.Net;

public static async Task<IActionResult> Run(
    HttpRequest req, ILogger log)
{
    string name = req.Query["name"];
    return name != null
        ? (ActionResult)new OkObjectResult($"Hello, {name}")
        : new BadRequestObjectResult("Please pass a name on the query string");
}

Example: Queue-triggered JavaScript Function

module.exports = async function(context, myQueueItem) {
    context.log('Queue item:', myQueueItem);
};

4. Functions Triggers & Bindings

5. Hosting & Pricing Models

• Consumption is most cost-effective for infrequent workloads.

• Premium required for VNet, large memory/long executions, high-scale.

• Always consider execution time, memory, and extra resource consumption.

6. Deployment

• Methods: Azure Portal, Visual Studio/VS Code ("Publish" features), Azure CLI, GitHub Actions, Azure DevOps, ZIP deploy, ARM/Bicep templates.

• Continuous Deployment: Easily set up with GitHub, Azure Repos, or pipelines.

• CI/CD Example:
• Configure pipeline to build code, run tests.
• Deploy with az functionapp deployment or via web hooks.

Example: Deploying with Azure CLI

az functionapp create --resource-group <group> --os-type Linux \
  --consumption-plan-location <region> --runtime node \
  --runtime-version 18 --functions-version 4 --name <func-name> --storage-account <storage>

7. Configuration & Application Settings

• App Settings: Managed in Azure Portal, Azure CLI, or ARM templates; used for connection strings, app config, and secrets.

• Environment Variables: Access using standard environment variable syntax in code (Environment.GetEnvironmentVariable in .NET).

• Key Vault Integration: Securely reference secrets from Azure Key Vault in config.

• Function Proxies: Layer lightweight API gateway-style routing, URL rewriting, and aggregation.

8. Security & IAM

Example: Making Storage Calls with Managed Identity (C#)

var credential = new DefaultAzureCredential();
var blobServiceClient = new BlobServiceClient(new Uri("https://<account>.blob.core.windows.net/"), credential);

9. Scaling and Performance

• Auto Scaling: Consumption and Premium plans scale out automatically based on demand.

• Cold Start: Consumption plan can “cold start” functions (initial delay); Premium fixes this.

• Pre-Warmed Instances: Premium plan keeps VMs warm for no-delay response.

• Best Practices: Keep startup fast, minimize dependencies, avoid heavy static constructors.

10. Monitoring, Logging, and Diagnostics

• Application Insights: Rich tracing, distributed tracing, performance counters, custom metrics.

• Live Metrics Stream: See live function executions and failures.

• Integrated Logs: View/log output directly in Azure Portal, or stream to external services/SIEM.

11. Advanced Concepts

• Durable Functions: Write stateful workflows/orchestrations as code using function chaining, fan-out/fan-in, human interaction, and timers.
• Example scenario: Order processing workflow with checkpoints and retries.

• Function Proxies: Allows you to define routes and create composite/aggregated APIs.

• Hybrid Connections: Securely integrate with on-premises systems for legacy integration.

• Deployment Slots: Separate logical environments (preview, staging) for zero-downtime releases.

Example: Durable Function Chaining (C#)

[FunctionName("Orchestrator")]
public async Task<List<string>> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var outputs = new List<string>();
    outputs.Add(await context.CallActivityAsync<string>("SayHello", "Tokyo"));
    outputs.Add(await context.CallActivityAsync<string>("SayHello", "Seattle"));
    return outputs;
}

12. Common Scenarios & Patterns

• Event-driven processing: Blob uploads, Event Hub/Service Bus streams.

• Real-time APIs: HTTP-triggered functions as microservices.

• Data transformation: ETL in serverless model.

• IoT aggregation: Process and consolidate telemetry.

• Automated jobs: Scheduled cleanups, reporting, notifications.

13. Summary Table: Azure Functions Features

FAQ

• Consumption Plan: Serverless, scales automatically, pay per execution, scales to zero when idle, susceptible to cold starts.

• Premium Plan: Always available, pre-warmed instances prevent cold starts, supports VNet integration, longer execution times, pay per vCPU and memory.

• Dedicated (App Service) Plan: Runs on App Service VMs, manual scaling, no cold starts but pay for VM uptime, suitable for predictable workloads.

1. Create a new Function App project using Azure Functions extension in VS Code or CLI (func init).

2. Add a function with a trigger (func new), write your code.

3. Test locally using Azure Functions Core Tools (func start).

4. Deploy via Azure CLI (az functionapp deployment), VS Code Publish, or CI/CD pipelines.

Intermediate Questions and Answers

Advanced & Tricky Questions and Answers

Scenario-Based and DevOps-Oriented Questions and Answers