Snabbstart: Skapa en C# Durable Functions-app

Använd Durable Functions, en funktion i Azure Functions, för att skriva tillståndskänsliga serverlösa arbetsflöden i C#. I den här snabbstartsguiden ska du klona och köra ett exempelprogram som demonstrerar orkestreringsmönstret för funktionskedjning:

• Funktionskedjning: Anropar aktiviteter i följd (Tokyo → Seattle → London).

I slutet kommer orkestreringen att köras lokalt med Durable Task Scheduler-emulatorn och kunna visa dess status på instrumentpanelen.

Förutsättningar

• .NET 8 SDK eller senare installerat.
• Azure Functions Core Tools v4 eller senare.
• Docker för att köra emulatorn och Azurite.
• Klona Durable Task Scheduler GitHub-lagringsplatsen för att använda snabbstartsexemplet.

Konfigurera Durable Task Scheduler-emulatorn

Durable Task Scheduler-emulatorn tillhandahåller en lokal utvecklingsmiljö så att du kan testa orkestreringar utan en Azure prenumeration. Värden för .NET Functions kräver också Azurite för lokal lagring.

Starta båda containrarna:

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

Kör snabbstartsexemplet

1. Gå till exempelkatalogen Hello Cities:

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

2. Skapa en local.settings.json fil med emulatorns konfiguration:

   {
     "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. Bygg projektet:

   dotnet build
   

4. Starta funktionsappen:

   func start
   

5. I en separat terminal utlöser du orkestreringen:

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

   Svaret innehåller status-URL:er för orkestreringsinstansen. Kopiera värdet statusQueryGetUri och kör det för att kontrollera resultatet:

   Invoke-RestMethod -Uri $response.statusQueryGetUri
   

Förväntade utdata

POST-begäran returnerar ett JSON-svar med status-URL:er. Ett exempel:

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

När du frågar statusQueryGetUri och orkestreringen är runtimeStatusCompletedkan du hitta hälsningsresultatet i fältet output :

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

Öppna instrumentpanelen för Durable Task Scheduler på http://localhost:8082 om du vill visa orkestreringsstatus och körningshistorik.

Förstå koden

Exempelprojektet i DurableFunctionsOrchestrationCSharp1.cs innehåller alla tre funktionstyper som behövs för en Durable Functions app.

Aktivitetsfunktion

Aktiviteten SayHello tar ett stadsnamn och returnerar en hälsning:

[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}!";
}

Orchestrator-funktion

Orkestratorn anropar SayHello sekventiellt för tre städer:

[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;
}

Klientfunktion

En HTTP-utlöst klientfunktion startar orkestreringen:

[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

Exemplet använder Durable Task Scheduler-emulatorn som lagringsbackend. Detta konfigureras i host.json:

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

Emulatorns anslutningssträng och namnet på aktivitetshubben anges i local.settings.json:

{
  "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"
  }
}

Rensa resurser

Stoppa emulatorcontainrarna när du är klar:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Nästa steg

• Läs mer om vanliga Durable Functions applikationsmönster.
• Lär dig mer om Durable Functions lagringsproviders.