Quickstart: Crie uma aplicação C# Durable Functions

Utilize o Durable Functions, uma funcionalidade do Funções do Azure, para escrever fluxos de trabalho sem servidor com estado em C#. Neste início rápido, clona e executa uma aplicação de exemplo que demonstra o padrão de orquestração por encadeamento de funções:

• Encadeamento de funções: Chama atividades sequencialmente (Tóquio → Seattle → Londres).

No final, terá a orquestração em execução localmente com o emulador Durable Task Scheduler e poderá consultar o respetivo estado no painel de controlo.

Pré-requisitos

• .NET 8 SDK ou posterior instalado.
• Funções do Azure Core Tools v4 ou posterior.
• Docker para correr o emulador e o Azurite.
• Clone o repositório GitHub Durable Task Scheduler para usar o exemplo de início rápido.

Configurar o emulador do Durable Task Scheduler

O emulador Durable Task Scheduler fornece um ambiente de desenvolvimento local para que possa testar orquestrações sem uma subscrição Azure. O host .NET Functions também requer Azurite para armazenamento local.

Inicie ambos os recipientes:

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

Executa a amostra de início rápido

1. Navegue até ao diretório de exemplos Hello Cities:

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

2. Crie um local.settings.json ficheiro com a configuração do emulador:

   {
     "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. Compile o projeto:

   dotnet build
   

4. Inicie a aplicação de funções:

   func start
   

5. Num terminal separado, acione a orquestração:

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

   A resposta contém URLs de estado da instância de orquestração. Copie o statusQueryGetUri valor e execute para verificar o resultado:

   Invoke-RestMethod -Uri $response.statusQueryGetUri
   

Resultados esperados

O pedido POST devolve uma resposta JSON com URLs de estado. Por exemplo:

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

Quando consulta statusQueryGetUri e o runtimeStatus da orquestração é Completed, pode encontrar os resultados de saudação no campo output:

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

Abra o painel do Durable Task Scheduler em http://localhost:8082 para ver o estado da orquestração e o histórico de execução.

Entenda o código

O projeto de exemplo em DurableFunctionsOrchestrationCSharp1.cs contém os três tipos de funções necessários para uma aplicação Durable Functions.

Função de atividade

A SayHello atividade adota o nome da cidade e responde com uma saudação:

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

Função orquestradora

O orquestrador chama SayHello sequencialmente para três cidades:

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

Função cliente

Uma função cliente ativada por HTTP inicia a orquestração:

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

Configuração

O exemplo utiliza o emulador Durable Task Scheduler como backend de armazenamento. Isto está configurado em host.json:

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

A cadeia de ligação do emulador e o nome do hub de tarefas estão definidos em 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"
  }
}

Limpeza de recursos

Pare os contentores do emulador quando terminar:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Passos seguintes

• Aprenda sobre padrões comuns de aplicações de Durable Functions.
• Saiba mais sobre os fornecedores de armazenamento do Durable Functions.