Schnellstart: Erstellen einer C#-Durable Functions-App

Verwenden Sie Durable Functions, ein Feature von Azure Functions, um zustandslose serverlose Workflows in C# zu schreiben. In dieser Schnellstartanleitung klonen und führen Sie eine Beispiel-App aus, die das Funktionsketten-Orchestrierungsmuster veranschaulicht:

• Funktionskette: Ruft Aktivitäten sequenziell auf (Tokio → Seattle → London).

Am Ende haben Sie die Orchestrierung lokal mit dem Emulator Durable Task Scheduler ausgeführt und können ihren Status im Dashboard anzeigen.

Voraussetzungen

• .NET 8 SDK oder höher installiert.
• Azure Functions Core Tools v4 oder höher.
• Docker für die Ausführung des Emulators und der Azurite.
• Klonen Sie den Durable Task Scheduler GitHub Repository, um das Schnellstartbeispiel zu verwenden.

Einrichten des Emulators "Durable Task Scheduler"

Der Emulator Durable Task Scheduler stellt eine lokale Entwicklungsumgebung bereit, sodass Sie Orchestrierungen ohne Azure Abonnement testen können. Der Host für .NET Funktionen erfordert außerdem Azurite für den lokalen Speicher.

Starten Sie beide Container:

docker run -d --name dtsemulator -p 8080:8080 -p 8082:8082 \
  mcr.microsoft.com/dts/dts-emulator:latest

docker run -d --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 \
  mcr.microsoft.com/azure-storage/azurite

Ausführen des Schnellstartbeispiels

1. Navigieren Sie zum Beispielverzeichnis "Hello Cities":

   cd samples/durable-functions/dotnet/HelloCities/http
   

2. Erstellen Sie eine local.settings.json Datei mit der Emulatorkonfiguration:

   {
     "IsEncrypted": false,
     "Values": {
       "AzureWebJobsStorage": "UseDevelopmentStorage=true",
       "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
       "DURABLE_TASK_SERVICE_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None",
       "TASKHUB_NAME": "default"
     }
   }
   

3. Erstellen Sie das Projekt:

   dotnet build
   

4. Starten Sie die Funktions-App:

   func start
   

5. Starten Sie in einem separaten Terminal die Orchestrierung:

   $response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/DurableFunctionsOrchestrationCSharp1_HttpStart
   $response
   

   Die Antwort enthält Status-URLs für die Orchestrierungsinstanz. Kopieren Sie den statusQueryGetUri Wert, und führen Sie ihn aus, um das Ergebnis zu überprüfen:

   Invoke-RestMethod -Uri $response.statusQueryGetUri
   

Erwartete Ausgabe

Die POST-Anforderung gibt eine JSON-Antwort mit Status-URLs zurück. Zum Beispiel:

{
  "id": "<instanceId>",
  "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/<instanceId>?code=...",
  "sendEventPostUri": "...",
  "terminatePostUri": "...",
  "purgeHistoryDeleteUri": "..."
}

Wenn Sie statusQueryGetUri abfragen und das runtimeStatus der Orchestrierung Completed ist, finden Sie die Begrüßungsergebnisse im Feld output:

{
  "name": "DurableFunctionsOrchestrationCSharp1",
  "runtimeStatus": "Completed",
  "output": ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
}

Öffnen Sie das Durable Task Scheduler-Dashboard unter http://localhost:8082, um den Orchestrierungsstatus und den Ausführungsverlauf einzusehen.

Grundlegendes zum Code

Das Beispielprojekt in DurableFunctionsOrchestrationCSharp1.cs enthält alle drei Funktionstypen, die für eine Durable Functions App erforderlich sind.

Aktivitätsfunktion

Die SayHello Aktivität nimmt einen Stadtnamen und gibt eine Begrüßung zurück:

[Function(nameof(SayHello))]
public static string SayHello([ActivityTrigger] string name, FunctionContext executionContext)
{
    ILogger logger = executionContext.GetLogger("SayHello");
    logger.LogInformation("Saying hello to {name}.", name);
    return $"Hello {name}!";
}

Orchestratorfunktion

Der Orchestrator ruft SayHello nacheinander für drei Städte auf:

[Function(nameof(DurableFunctionsOrchestrationCSharp1))]
public static async Task<List<string>> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    ILogger logger = context.CreateReplaySafeLogger(nameof(DurableFunctionsOrchestrationCSharp1));
    logger.LogInformation("Saying hello.");
    var outputs = new List<string>();

    outputs.Add(await context.CallActivityAsync<string>(nameof(SayHello), "Tokyo"));
    outputs.Add(await context.CallActivityAsync<string>(nameof(SayHello), "Seattle"));
    outputs.Add(await context.CallActivityAsync<string>(nameof(SayHello), "London"));

    return outputs;
}

Client-Funktion

Eine VOM HTTP ausgelöste Clientfunktion startet die Orchestrierung:

[Function("DurableFunctionsOrchestrationCSharp1_HttpStart")]
public static async Task<HttpResponseData> HttpStart(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    [DurableClient] DurableTaskClient client,
    FunctionContext executionContext)
{
    ILogger logger = executionContext.GetLogger("DurableFunctionsOrchestrationCSharp1_HttpStart");
    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
        nameof(DurableFunctionsOrchestrationCSharp1));

    logger.LogInformation("Started orchestration with ID = '{instanceId}'.", instanceId);
    return await client.CreateCheckStatusResponseAsync(req, instanceId);
}

Konfiguration

Im Beispiel wird der Emulator "Durable Task Scheduler" als Speicher-Back-End verwendet. Dies ist konfiguriert in host.json:

{
  "version": "2.0",
  "extensions": {
    "durableTask": {
      "storageProvider": {
        "type": "azureManaged",
        "connectionStringName": "DURABLE_TASK_SERVICE_CONNECTION_STRING"
      },
      "hubName": "%TASKHUB_NAME%"
    }
  }
}

Der Emulator Verbindungszeichenfolge und der Name des Aufgabenhubs werden in local.settings.json festgelegt:

{
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
    "DURABLE_TASK_SERVICE_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None",
    "TASKHUB_NAME": "default"
  }
}

Bereinigen von Ressourcen

Beenden Sie die Emulatorcontainer, wenn Sie fertig sind:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Nächste Schritte

• Erfahren Sie mehr über common Durable Functions App-Muster.
• Erfahren Sie mehr über Durable Functions Speicheranbieter.