Azure Functions: Schritt-für-Schritt-Anleitung für serverlose Architektur in der Cloud. Praxisnahe Tipps für Unternehmen.

Das Problem mit Servern, die Sie nicht brauchen

Stellen Sie sich folgendes Szenario vor: Ein mittelständisches Unternehmen betreibt eine E-Commerce-Plattform mit 50.000 täglichen Bestellungen. Die Backend-Prozesse – Bestätigungsmails, Lageraktualisierung, Zahlungsabwicklung – laufen auf drei virtuellen Maschinen mit je 4 vCPUs. Kostenpunkt: rund 800€ monatlich, unabhängig von der tatsächlichen Auslastung. An normalen Tagen sind diese Server zu 15% ausgelastet. Am Black Friday droht Überlastung.

Das ist kein Einzelfall. Laut einer IDC-Studie aus 2023 nutzen Unternehmen durchschnittlich nur 20-30% ihrer Cloud-Ressourcen effektiv. Die Lösung liegt in einer Serverless Architektur – und Azure Functions ist Microsofts Flaggschiff dafür.

In diesem Guide zeige ich Ihnen, wie Sie Azure Functions praktisch implementieren. Nicht die Theorie aus der Dokumentation, sondern das Vorgehen aus über 40 Production-Deployments.

Was ist Azure Functions? Die Architektur erklärt

Azure Functions ist Microsofts serverloses Computing-Angebot innerhalb des Azure-Ökosystems. Im Kern handelt es sich um einen Event-Driven-Compute-Service, der Ihren Code ausführt, sobald ein Trigger aktiviert wird – ohne dass Sie Server verwalten, patchen oder skalieren müssen.

Serverless bedeutet nicht "ohne Server"

Ein häufiges Missverständnis: "Serverless" bedeutet nicht, dass keine Server existieren. Es bedeutet, dass Sie sich nicht um die Server kümmern müssen. Microsoft verwaltet die Infrastruktur, skaliert automatisch und sorgt für Hochverfügbarkeit.

Kernkonzepte von Azure Functions:

  • Function App: Der Container für Ihre Functions – definiert Hosting-Plan, Region und Deployment-Slot
  • Trigger: Das Event, das Ihre Function startet (HTTP, Timer, Queue, Event Hub, Blob, etc.)
  • Bindings: Input/Output-Verbindungen zu anderen Azure-Diensten ohne Integrationscode
  • Runtime: Die Execution-Umgebung (derzeit Node.js 20 LTS, Python 3.11, .NET 8, Java 17, PowerShell 7.2)

Wann Azure Functions sinnvoll sind

Azure Functions eignen sich hervorragend für:

  • Event-Driven-Workloads: Wenn Aktionen durch Events ausgelöst werden (neue Bestellung → Bestätigungsmail)
  • Unregelmäßige Last: Batch-Jobs, die stündlich/täglich laufen, nicht kontinuierlich
  • Microservices-Backends: Kleine, fokussierte Funktionsbausteine statt monolithischer Services
  • Integration: Point-to-Point-Integration zwischen Cloud-Diensten ohne ESB

Nicht geeignet sind Functions für:

  • Langläufige Prozesse über 60 Minuten (Premium Plan max. 60 Min, Standard 5-10 Min)
  • Stateful High-Throughput-Processing (dafür Azure Kubernetes Service oder Container Instances)
  • Szenarien mit strikten Cold-Start-Anforderungen ohne Premium-Plan

Schritt-für-Schritt: Azure Functions implementieren

Schritt 1: Azure-Konto und Region einrichten

Bevor Sie Ihre erste Function deployen, benötigen Sie ein Azure-Konto. Für Produktivworkloads empfehle ich:

  1. Azure Portal unter portal.azure.com öffnen
  2. Ressourcengruppe erstellen (z.B. rg-produktion-functions)
  3. Region wählen: Für deutsche Unternehmen ist West Europe (Niederlande) oder Germany West Central (Frankfurt) optimal. Die Latenz zu deutschen Rechenzentren liegt bei <10ms.

Kostenloser Einstieg: Azure bietet ein kostenloses Konto mit 750 Stunden B1S VMs, 5 GB Blob Storage und 250 MB SQL Database – ausreichend für Entwicklung und Tests.

Schritt 2: Function App erstellen

Im Azure Portal:

  1. "Ressource erstellen" → "Function App" suchen

  2. Folgende Konfiguration wählen:

    Einstellung Empfehlung Begründung
    Runtime Python 3.11 / Node.js 20 LTS LTS-Versionen mit Langzeit-Support
    Hosting Plan Consumption Pay-per-use, empfohlen für Einsteiger
    Region Germany West Central DSGVO-konform, niedrige Latenz
    Betriebssystem Linux Bessere Performance bei Python/Node.js
    Monitor Application Insights aktivieren Pflicht für Production

Alternativ via Azure CLI:

az functionapp create \n  --resource-group rg-meine-firma \n  --consumption-plan-location westeurope \n  --runtime python \n  --runtime-version 3.11 \n  --functions-version 4 \n  --name mein-functions-app \n  --storage-account meinestorage \n  --os-type Linux

Schritt 3:本地 Entwicklungsumgebung einrichten

Für die lokale Entwicklung benötigen Sie:

  1. Azure Functions Core Tools (Version 4.x):

    npm install -g azure-functions-core-tools@4

  2. VS Code mit Azure Functions Extension

  3. Python 3.11 oder Node.js 20 LTS

Initialisieren Sie ein neues Projekt:

func init mein-projekt --python
cd mein-projekt
func new --name BestellungBestaetigen --template "HTTP trigger"

Schritt 4: Die erste Function – Bestellungsbestätigung

Erstellen wir eine Function, die HTTP-Requests empfängt und eine Bestätigung versendet:

import azure.functions as func
import logging
from datetime import datetime

app = func.App()

@app.function_name(name="BestellungBestaetigen")
@app.route(route="bestellung/{bestellId}", methods=["POST"])
@app.cosmos_db_input(arg_name="inputDocument", 
                      database_name="ECommerce",
                      collection_name="Bestellungen",
                      id="{bestellId}",
                      connection="COSMOS_DB_CONNECTION")
def main(req: func.HttpRequest, inputDocument: func.DocumentList) -> func.HttpResponse:
    logging.info(f"Bestellung {req.route_params.get('bestellId')} wird verarbeitet")
    
    if not inputDocument:
        return func.HttpResponse("Bestellung nicht gefunden", status_code=404)
    
    # Hier: E-Mail-Versand, Lageraktualisierung, etc.
    bestellung = inputDocument[0].to_json()
    
    return func.HttpResponse(
        f"Bestellung {bestellId} bestätigt um {datetime.now()}",
        mimetype="application/json",
        status_code=200
    )

Wichtige Best Practices aus der Praxis:

  • Idempotenz: Ihre Function muss mehrfache Aufrufe überstehen (Netzwerk-Retry). Fügen Sie eine Request-ID-Prüfung ein.
  • Statelessness: Functions speichern keinen Zustand zwischen Aufrufen. Nutzen Sie Azure Cosmos DB oder Redis für persistente Daten.
  • Fehlerbehandlung: Implementieren Sie retry-Policies mit Exponential Backoff für externe API-Aufrufe.

Schritt 5: Durable Functions für komplexe Workflows

Wenn Sie orchestrations benötigen – etwa eine Bestellung, die mehrere Services in einer definierten Reihenfolge aufruft – nutzen Sie Durable Functions:

from azure.durable_functions import DurableOrchestrationClient
from datetime import timedelta

@app.orchestration_trigger(context_name="context")
def bestellung_orchestrator(context):
    bestellId = context.get_input()
    
    # Schritt 1: Zahlung validieren
    payment_result = yield context.call_activity("ZahlungValidieren", bestellId)
    if not payment_result["success"]:
        return {"status": "failed", "reason": "Payment failed"}
    
    # Schritt 2: Lager reservieren
    yield context.call_activity("LagerReservieren", bestellId)
    
    # Schritt 3: Bestätigung senden
    yield context.call_activity("BestaetigungSenden", bestellId)
    
    return {"status": "completed", "bestellId": bestellId}

Durable Functions sind ideal für:

  • Langläufige Genehmigungsworkflows (Human-in-the-loop)
  • Szenarien mit parallelen/sequenziellen Service-Aufrufen
  • Zustandsautomaten-Implementierungen

Schritt 6: Deployment und CI/CD

Option A: GitHub Actions (empfohlen)

Erstellen Sie .github/workflows/deploy.yml:

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

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Python 3.11
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      
      - name: Install dependencies
        run: pip install -r requirements.txt
      
      - name: Azure Login
        uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}
      
      - name: Deploy to Azure Functions
        uses: Azure/functions-action@v1
        with:
          app-name: 'mein-functions-app'
          package: '.'

Option B: Azure CLI für direktes Deployment

func azure functionapp publish mein-functions-app

Schritt 7: Monitoring und Observability

Application Insights ist standardmäßig integriert. Im Azure Portal sehen Sie:

  • Invocations: Anzahl und Erfolgsrate
  • Duration: Durchschnittliche Ausführungszeit (Ziel: <500ms für HTTP-Triggers)
  • Cold Starts: Zeit bis zum ersten Request nach Inaktivität
  • Failures: Fehlerhafte Aufrufe mit Stacktraces

Kritische Metriken, die Sie im Auge behalten sollten:

  • Average Response Time: >1 Sekunde deutet auf Optimierungsbedarf hin
  • Memory Consumption: >1,5 GB im Consumption Plan führt zu Timeouts
  • Connection Pool Exhaustion: Maximal 600 gleichzeitige Connections pro Instance
// Kusto Query: Fehlgeschlagene Functions der letzten 24 Stunden
requests
| where success == false
| where timestamp > ago(24h)
| summarize count() by name, resultCode
| order by count_ desc

Azure Functions Preise: Was kostet serverlos wirklich?

Microsoft bietet drei Hosting-Pläne:

Plan Preis Cold Start Max Execution Skalierung
Consumption 0,20€ pro Mio. Aufrufe + 0,000012€ pro GB-s 1-3 Sekunden 5-10 Minuten Automatisch, max 200 Instances
Premium Ab 34€ pro Monat + Nutzung <100ms 60 Minuten Immer warm, VNet-Integration
Dedicated VM-Preise + Functions-Gebühr Keine 60 Minuten Manuelle Skalierung

Praxis-Beispiel: Eine Function, die 100.000 Mal täglich aufgerufen wird (ca. 3 Mio./Monat), mit 128 MB RAM und 500ms Ausführungszeit:

  • GB-s pro Monat: 128 MB × 0,5s × 3.000.000 = 192.000 GB-s
  • Kosten (Consumption): 3.000.000 Aufrufe × 0,20€/Mio. + 192.000 GB-s × 0,000012€ = 0,60€ + 2,30€ = ~2,90€/Monat

Das ist ein enormer Kostenvorteil gegenüber Always-On VMs, die selbst bei Minimal-Auslastung 15-30€/Monat kosten.

Sicherheit: Azure Functions absichern

1. Managed Identity nutzen

Keine Credentials in Code oder Config – nutzen Sie system- oder user-assigned Managed Identities:

from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient

credential = DefaultAzureCredential()
key_vault_url = os.environ["KEY_VAULT_URL"]
secret_client = SecretClient(key_vault_url, credential)
db_password = secret_client.get_secret("db-password").value

2. Netzwerk-Isolation

Für Production-Workloads mit sensiblen Daten:

  • Premium Plan: VNet-Integration aktivieren
  • Private Endpoints: Functions nur intern erreichbar machen
  • IP-Restrictions: Nur erlaubte IP-Bereiche zulassen

3. Application Settings schützen

Nutzen Sie Key Vault References für sensitive Konfiguration:

az functionapp config appsettings set \
  --name mein-functions-app \
  --resource-group rg-produktion \
  --settings "COSMOS_DB_CONNECTION=@Microsoft.KeyVault(SecretUri=https://mein-kv.vault.azure.net/secrets/cosmos-key)"

Best Practices aus der Praxis

Nach Dutzenden Production-Deployments haben sich folgende Patterns bewährt:

Do's

✅ Design für Failure: Jede Function kann fehlschlagen. Implementieren Sie idempotente Operations und Dead-Letter-Queues für fehlgeschlagene Events.

✅ Separation of Concerns: Eine Function = eine Verantwortung. Nicht "BestellungKomplettAbwickeln", sondern separate Functions für Validierung, Zahlung, Versand.

✅ Connection Pooling: Erstellen Sie DB-Connections einmalig im globalen Scope, nicht in jedem Function-Aufruf. Das reduziert Latenz um 30-50%.

✅ Async where possible: Nutzen Sie Output Bindings für Fire-and-Forget-Operations, statt auf externe Calls zu warten.

Don'ts

❌ Keine Connection Strings oder Secrets im Code – nutzen Sie Key Vault + Managed Identity

❌ Vermeiden Sie große Dependencies – jede Library erhöht Cold Start Time. Prüfen Sie mit func start --language-worker "-v" die Ladezeiten.

❌ Nicht zu viele parallele Functions starten – Azure skaliert automatisch, aber ein plötzlicher Traffic-Spike kann zu throttling führen. Nutzen Sie Queue-basierte Trigger für kontrollierte Lastverteilung.

Fazit: Ist Azure Functions das Richtige für Sie?

Azure Functions bietet eine ausgereifte, enterprise-taugliche Plattform für serverloses Computing. Die Stärken liegen in der nahtlosen Integration mit anderen Azure-Diensten, dem pay-per-use-Modell und der automatischen Skalierung.

Meine Empfehlung: Starten Sie mit dem Consumption Plan für neue Projekte. Die niedrigen Einstiegskosten und das Fehlen von Commitment machen Azure Functions ideal für die Erprobung neuer Use Cases. Wenn Sie Cold Start-Latenz <100ms benötigen, wechseln Sie zum Premium Plan.

Für Teams, die von AWS Lambda oder Google Cloud Functions kommen: Azure Functions bietet vergleichbare Capabilities mit besserer Visual-Studio-Integration und Azure-Ökosystem-Anbindung.

Der Weg zur Production: Beginnen Sie mit einer einfachen HTTP-triggered Function, implementieren Sie Application Insights von Tag 1, und bauen Sie Ihre CI/CD-Pipeline strukturiert auf. Nach 2-3 Wochen haben Sie ein fundiertes Verständnis der Plattform.

Checkliste: Azure Functions Production-Ready

  • Resource Group und Region definiert (idealerweise Germany West Central)
  • Function App erstellt mit Application Insights
  • Managed Identity aktiviert für alle Azure-Service-Verbindungen
  • Key Vault Integration für Secrets konfiguriert
  • Application Settings als Key Vault References definiert
  • Function-Level Logging implementiert (nicht nur try/catch)
  • Health Check Endpoint erstellt (/api/health)
  • CI/CD Pipeline mit GitHub Actions oder Azure DevOps
  • Infra-as-Code (Bicep/Terraform) für reproduzierbare Deployments
  • Load Testing durchgeführt (Application Insights oder k6)
  • Kosten-Monitoring eingerichtet (Azure Cost Management)
  • Dokumentation: Deployment-Prozess, Rollback-Strategie, On-Call-Guide

Mit dieser Checkliste sind Sie bereit für den Production-Betrieb mit Azure Functions.

Wöchentliche Cloud-Insights — kostenlos

Praktische Leitfäden zu Cloud-Kosten, Sicherheit und Strategie. Kein Spam.

Comments

Leave a comment