Durable Functions in Azure: Orchestrierung leicht gemacht

15 Dec 2020 - Matthias Voigt

Azure Durable Functions bieten eine leistungsstarke Möglichkeit, zustandsbehaftete Workflows in einer serverlosen Umgebung zu erstellen und zu orchestrieren. In diesem Artikel werde ich erläutern, wie Durable Functions funktionieren, welche Vorteile sie bieten und wie man sie in der Praxis einsetzt.

Was sind Durable Functions?

Durable Functions sind eine Erweiterung von Azure Functions, die es ermöglichen, langfristige, zustandsbehaftete Workflows zu erstellen. Mit Durable Functions können Entwickler komplexe Orchestrierungen definieren, ohne sich um die zugrunde liegende Infrastruktur kümmern zu müssen.

Vorteile von Durable Functions

1. Statusverwaltung: Durable Functions verwalten den Zustand automatisch, was die Implementierung zustandsbehafteter Workflows vereinfacht.
2. Skalierbarkeit: Dank der serverlosen Natur von Azure Functions skalieren Durable Functions automatisch mit der Last.
3. Fehlerbehandlung: Eingebaute Mechanismen zur Fehlerbehandlung und Wiederholung erleichtern die Implementierung robuster Workflows.
4. Kostenoptimierung: Abrechnung erfolgt nach Verbrauch, wodurch nur für tatsächlich genutzte Ressourcen gezahlt wird.

Komponenten von Durable Functions

Durable Functions bestehen aus drei Hauptkomponenten:

1. Orchestrator Function: Definiert den Workflow und orchestriert die Ausführung anderer Funktionen.
2. Activity Function: Führt die eigentlichen Aufgaben innerhalb des Workflows aus.
3. Client Function: Startet und verwaltet die Orchestrator Functions.

Beispiel: Erstellen eines einfachen Workflows

Schritt 1: Projekt einrichten

Erstelle ein neues Azure Functions-Projekt in Visual Studio:

1. Öffne Visual Studio.
2. Gehe zu “Datei” > “Neues Projekt”.
3. Wähle “Azure Functions” und klicke auf “Weiter”.
4. Gib deinem Projekt einen Namen und wähle den Speicherort aus.
5. Wähle “Azure Functions v3 (.NET Core)” und “Durable Functions Orchestrator” als Vorlage.

Schritt 2: Orchestrator Function definieren

Definiere eine Orchestrator Function, die den Workflow orchestriert:

using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Http;

public static class FunctionOrchestrator
{
    [FunctionName("RunOrchestrator")]
    public static async Task<List<string>> RunOrchestrator(
        [OrchestrationTrigger] IDurableOrchestrationContext context)
    {
        var outputs = new List<string>();

        // Definieren der Workflow-Schritte
        outputs.Add(await context.CallActivityAsync<string>("Function1", "Tokyo"));
        outputs.Add(await context.CallActivityAsync<string>("Function1", "Seattle"));
        outputs.Add(await context.CallActivityAsync<string>("Function1", "London"));

        // Rückgabe der Ergebnisse
        return outputs;
    }

    [FunctionName("Function1")]
    public static string SayHello([ActivityTrigger] string name, ILogger log)
    {
        log.LogInformation($"Saying hello to {name}.");
        return $"Hello {name}!";
    }

    [FunctionName("HttpStart")]
    public static async Task<IActionResult> HttpStart(
        [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req,
        [DurableClient] IDurableOrchestrationClient starter,
        ILogger log)
    {
        // Starten der Orchestrator Function
        string instanceId = await starter.StartNewAsync("RunOrchestrator", null);

        log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

        return starter.CreateCheckStatusResponse(req, instanceId);
    }
}

Schritt 3: Activity Function definieren

Die Activity Function führt die eigentlichen Aufgaben aus:

[FunctionName("Function1")]
public static string SayHello([ActivityTrigger] string name, ILogger log)
{
    log.LogInformation($"Saying hello to {name}.");
    return $"Hello {name}!";
}

Schritt 4: Client Function definieren

Die Client Function startet die Orchestrator Function und gibt den Status zurück:

[FunctionName("HttpStart")]
public static async Task<IActionResult> HttpStart(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req,
    [DurableClient] IDurableOrchestrationClient starter,
    ILogger log)
{
    string instanceId = await starter.StartNewAsync("RunOrchestrator", null);
    log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

    return starter.CreateCheckStatusResponse(req, instanceId);
}

Fazit

Azure Durable Functions bieten eine leistungsstarke und flexible Möglichkeit, zustandsbehaftete Workflows in einer serverlosen Umgebung zu orchestrieren. Sie vereinfachen die Implementierung komplexer Geschäftslogik und bieten dabei Skalierbarkeit, Fehlerbehandlung und Kostenoptimierung. Es lohnt sich, die Möglichkeiten von Durable Functions in zukünftigen Projekten zu erkunden und zu nutzen.

Für weitere Details und eine ausführliche Anleitung besuche die offizielle Microsoft-Dokumentation.