O que é a Durable Functions?What are Durable Functions?

Funções Duradouras é uma extensão de Funções Azure que permite escrever funções imponentes num ambiente de computação sem servidor.Durable Functions is an extension of Azure Functions that lets you write stateful functions in a serverless compute environment. A extensão permite definir fluxos de trabalho imponentes escrevendo funções orquestradoras e entidades imponentes, escrevendo funções de entidade utilizando o modelo de programação Azure Functions.The extension lets you define stateful workflows by writing orchestrator functions and stateful entities by writing entity functions using the Azure Functions programming model. Nos bastidores, a extensão gere o estado, os postos de controlo e o recomeço para si, permitindo-lhe focar-se na sua lógica de negócio.Behind the scenes, the extension manages state, checkpoints, and restarts for you, allowing you to focus on your business logic.

Linguagens suportadasSupported languages

Funções Duradouras suportam atualmente os seguintes idiomas:Durable Functions currently supports the following languages:

  • C.: ambas as bibliotecas de classes pré-recompensadas e o script C#.C#: both precompiled class libraries and C# script.
  • JavaScript: suportado apenas para a versão 2.x do tempo de execução das Funções Azure.JavaScript: supported only for version 2.x of the Azure Functions runtime. Requer a versão 1.7.0 da extensão funções duradouras, ou uma versão posterior.Requires version 1.7.0 of the Durable Functions extension, or a later version.
  • Python: requer a versão 1.8.5 da extensão funções duráveis, ou uma versão posterior.Python: requires version 1.8.5 of the Durable Functions extension, or a later version.
  • F#: bibliotecas de classes pré-recompensadas e script F#.F#: precompiled class libraries and F# script. F# O script só é suportado para a versão 1.x do tempo de execução das Funções Azure.F# script is only supported for version 1.x of the Azure Functions runtime.

As Funções Duradouras têm como objetivo apoiar todas as línguas Azure Functions.Durable Functions has a goal of supporting all Azure Functions languages. Consulte a lista de problemas de funções duradouras para obter o mais recente estado de trabalho para suportar idiomas adicionais.See the Durable Functions issues list for the latest status of work to support additional languages.

Tal como as Funções Azure, existem modelos para o ajudar a desenvolver Funções Duráveis utilizando o Visual Studio 2019, o Visual Studio Codee o portal Azure.Like Azure Functions, there are templates to help you develop Durable Functions using Visual Studio 2019, Visual Studio Code, and the Azure portal.

Padrões de aplicaçãoApplication patterns

O caso de utilização primária para funções duradouras está a simplificar requisitos complexos e apátridas de coordenação em aplicações sem servidor.The primary use case for Durable Functions is simplifying complex, stateful coordination requirements in serverless applications. As seguintes secções descrevem padrões típicos de aplicação que podem beneficiar de Funções Duradouras:The following sections describe typical application patterns that can benefit from Durable Functions:

Padrão #1: Acorrentamento de funçõesPattern #1: Function chaining

No padrão de acorrentamento da função, uma sequência de funções executa numa ordem específica.In the function chaining pattern, a sequence of functions executes in a specific order. Neste padrão, a saída de uma função é aplicada à entrada de outra função.In this pattern, the output of one function is applied to the input of another function.

Um diagrama do padrão de acorrentamento da função

Pode utilizar funções duradouras para implementar o padrão de corrente de função de forma concisa, como mostrado no exemplo seguinte.You can use Durable Functions to implement the function chaining pattern concisely as shown in the following example.

Neste exemplo, os valores F1 , , e são os F2 F3 F4 nomes de outras funções na mesma aplicação de função.In this example, the values F1, F2, F3, and F4 are the names of other functions in the same function app. Pode implementar o fluxo de controlo utilizando construções normais de codificação imperativas.You can implement control flow by using normal imperative coding constructs. O código executa de cima para baixo.Code executes from the top down. O código pode envolver a semântica de fluxo de fluxo de linguagem existente, como condicional e loops.The code can involve existing language control flow semantics, like conditionals and loops. Pode incluir lógica de manuseamento de erros em try / catch / finally blocos.You can include error handling logic in try/catch/finally blocks.

[FunctionName("Chaining")]
public static async Task<object> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    try
    {
        var x = await context.CallActivityAsync<object>("F1", null);
        var y = await context.CallActivityAsync<object>("F2", x);
        var z = await context.CallActivityAsync<object>("F3", y);
        return  await context.CallActivityAsync<object>("F4", z);
    }
    catch (Exception)
    {
        // Error handling or compensation goes here.
    }
}

Pode utilizar o context parâmetro para invocar outras funções pelo nome, passar parâmetros e devolver a saída da função.You can use the context parameter to invoke other functions by name, pass parameters, and return function output. De cada vez que o código await chama, o quadro de funções duráveis verifica o progresso da instância de função atual.Each time the code calls await, the Durable Functions framework checkpoints the progress of the current function instance. Se o processo ou máquina virtual reciclar a meio da execução, a instância de função retoma a partir da await chamada anterior.If the process or virtual machine recycles midway through the execution, the function instance resumes from the preceding await call. Para mais informações, consulte a secção seguinte, Padrão #2: Ventilador para fora/ventilador dentroFor more information, see the next section, Pattern #2: Fan out/fan in.

Padrão #2: Ventilador para fora/ventilador emPattern #2: Fan out/fan in

No ventilador out/ventilador em padrão, executa várias funções em paralelo e, em seguida, aguarde que todas as funções terminem.In the fan out/fan in pattern, you execute multiple functions in parallel and then wait for all functions to finish. Muitas vezes, alguns trabalhos de agregação são feitos sobre os resultados que são devolvidos das funções.Often, some aggregation work is done on the results that are returned from the functions.

Um diagrama do ventilador fora/padrão de ventilador

Com funções normais, pode dispersar-se fazendo com que a função envie várias mensagens para uma fila.With normal functions, you can fan out by having the function send multiple messages to a queue. Voltar a entrar é muito mais desafiante.Fanning back in is much more challenging. Para abanar, numa função normal, escreve código para rastrear quando as funções desencadeadas pela fila terminam e, em seguida, armazena as saídas da função.To fan in, in a normal function, you write code to track when the queue-triggered functions end, and then store function outputs.

A extensão funções duráveis lida com este padrão com código relativamente simples:The Durable Functions extension handles this pattern with relatively simple code:

[FunctionName("FanOutFanIn")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var parallelTasks = new List<Task<int>>();

    // Get a list of N work items to process in parallel.
    object[] workBatch = await context.CallActivityAsync<object[]>("F1", null);
    for (int i = 0; i < workBatch.Length; i++)
    {
        Task<int> task = context.CallActivityAsync<int>("F2", workBatch[i]);
        parallelTasks.Add(task);
    }

    await Task.WhenAll(parallelTasks);

    // Aggregate all N outputs and send the result to F3.
    int sum = parallelTasks.Sum(t => t.Result);
    await context.CallActivityAsync("F3", sum);
}

O trabalho de ventilação é distribuído em várias instâncias da F2 função.The fan-out work is distributed to multiple instances of the F2 function. O trabalho é acompanhado através de uma lista dinâmica de tarefas.The work is tracked by using a dynamic list of tasks. Task.WhenAllé chamado a esperar que todas as funções chamadas terminem.Task.WhenAll is called to wait for all the called functions to finish. Em seguida, as F2 saídas de função são agregadas da lista de tarefas dinâmicas e transmitidas para a F3 função.Then, the F2 function outputs are aggregated from the dynamic task list and passed to the F3 function.

O controlo automático que ocorre na await chamada garante que uma Task.WhenAll possível falha ou reinicialização do meio do caminho não requer o reinício de uma tarefa já concluída.The automatic checkpointing that happens at the await call on Task.WhenAll ensures that a potential midway crash or reboot doesn't require restarting an already completed task.

Nota

Em circunstâncias raras, é possível que um acidente possa acontecer na janela depois de uma função de atividade terminar, mas antes que a sua conclusão seja guardada para a história da orquestração.In rare circumstances, it's possible that a crash could happen in the window after an activity function completes but before its completion is saved into the orchestration history. Se isso acontecer, a função de atividade seria re-executada desde o início após a recuperação do processo.If this happens, the activity function would re-run from the beginning after the process recovers.

Padrão #3: APIs HTTP AsyncPattern #3: Async HTTP APIs

O padrão da API HTTP async aborda o problema da coordenação do estado das operações de longa duração com clientes externos.The async HTTP API pattern addresses the problem of coordinating the state of long-running operations with external clients. Uma forma comum de implementar este padrão é tendo um ponto final HTTP desencadeando a ação de longa duração.A common way to implement this pattern is by having an HTTP endpoint trigger the long-running action. Em seguida, redirecione o cliente para um ponto final de estado que o cliente sonda para saber quando a operação está terminada.Then, redirect the client to a status endpoint that the client polls to learn when the operation is finished.

Um diagrama do padrão http API

As Funções Duradouras fornecem suporte incorporado para este padrão, simplificando ou mesmo removendo o código que precisa de escrever para interagir com execuções de função de longa duração.Durable Functions provides built-in support for this pattern, simplifying or even removing the code you need to write to interact with long-running function executions. Por exemplo, as amostras de arranque rápido de Funções Durable(C# e JavaScript) mostram um simples comando REST que pode utilizar para iniciar novas instâncias de função de orquestrador.For example, the Durable Functions quickstart samples (C# and JavaScript) show a simple REST command that you can use to start new orchestrator function instances. Após o início de um caso, a extensão expõe o webhook HTTP APIs que consulta o estado da função do orquestrador.After an instance starts, the extension exposes webhook HTTP APIs that query the orchestrator function status.

O exemplo a seguir mostra comandos REST que iniciam um orquestrador e consultam o seu estado.The following example shows REST commands that start an orchestrator and query its status. Para maior clareza, alguns detalhes do protocolo são omitidos do exemplo.For clarity, some protocol details are omitted from the example.

> curl -X POST https://myfunc.azurewebsites.net/api/orchestrators/DoWork -H "Content-Length: 0" -i
HTTP/1.1 202 Accepted
Content-Type: application/json
Location: https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/instances/b79baf67f717453ca9e86c5da21e03ec

{"id":"b79baf67f717453ca9e86c5da21e03ec", ...}

> curl https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/instances/b79baf67f717453ca9e86c5da21e03ec -i
HTTP/1.1 202 Accepted
Content-Type: application/json
Location: https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/instances/b79baf67f717453ca9e86c5da21e03ec

{"runtimeStatus":"Running","lastUpdatedTime":"2019-03-16T21:20:47Z", ...}

> curl https://myfunc.azurewebsites.net/runtime/webhooks/durabletask/instances/b79baf67f717453ca9e86c5da21e03ec -i
HTTP/1.1 200 OK
Content-Length: 175
Content-Type: application/json

{"runtimeStatus":"Completed","lastUpdatedTime":"2019-03-16T21:20:57Z", ...}

Como o tempo de funcionamento das Funções Duradouras gere o seu estado, não precisa de implementar o seu próprio mecanismo de rastreio de estado.Because the Durable Functions runtime manages state for you, you don't need to implement your own status-tracking mechanism.

A extensão Funções Duradouras expõe APIs HTTP incorporadas que gerem orquestrações de longa duração.The Durable Functions extension exposes built-in HTTP APIs that manage long-running orchestrations. Em alternativa, pode implementar este padrão utilizando os seus próprios gatilhos de função (como HTTP, uma fila ou Azure Event Hubs) e a ligação do cliente de orquestração.You can alternatively implement this pattern yourself by using your own function triggers (such as HTTP, a queue, or Azure Event Hubs) and the orchestration client binding. Por exemplo, pode utilizar uma mensagem de fila para desencadear a rescisão.For example, you might use a queue message to trigger termination. Ou, pode utilizar um gatilho HTTP protegido por uma política de autenticação do Azure Ative Directory em vez das APIs HTTP incorporadas que utilizam uma chave gerada para a autenticação.Or, you might use an HTTP trigger that's protected by an Azure Active Directory authentication policy instead of the built-in HTTP APIs that use a generated key for authentication.

Para obter mais informações, consulte o artigo de funcionalidades HTTP, que explica como pode expor processos assíncronos e de longa duração sobre HTTP utilizando a extensão de Funções Duradouras.For more information, see the HTTP features article, which explains how you can expose asynchronous, long-running processes over HTTP using the Durable Functions extension.

Padrão #4: MonitorPattern #4: Monitor

O padrão do monitor refere-se a um processo flexível e recorrente num fluxo de trabalho.The monitor pattern refers to a flexible, recurring process in a workflow. Um exemplo é a sondagem até que as condições específicas sejam satisfeitas.An example is polling until specific conditions are met. Pode utilizar um gatilho de temporizador regular para abordar um cenário básico, como um trabalho de limpeza periódica, mas o seu intervalo é estático e gerir as vidas de instâncias torna-se complexo.You can use a regular timer trigger to address a basic scenario, such as a periodic cleanup job, but its interval is static and managing instance lifetimes becomes complex. Pode utilizar funções duradouras para criar intervalos de recorrência flexíveis, gerir as tarefas e criar múltiplos processos de monitorização a partir de uma única orquestração.You can use Durable Functions to create flexible recurrence intervals, manage task lifetimes, and create multiple monitor processes from a single orchestration.

Um exemplo do padrão do monitor é inverter o cenário anterior da API HTTP HTTP.An example of the monitor pattern is to reverse the earlier async HTTP API scenario. Em vez de expor um ponto final para um cliente externo monitorizar uma operação de longa duração, o monitor de longa duração consome um ponto final externo e, em seguida, aguarda por uma mudança de estado.Instead of exposing an endpoint for an external client to monitor a long-running operation, the long-running monitor consumes an external endpoint, and then waits for a state change.

Um diagrama do padrão do monitor

Em algumas linhas de código, pode utilizar Funções Duráveis para criar múltiplos monitores que observam pontos finais arbitrários.In a few lines of code, you can use Durable Functions to create multiple monitors that observe arbitrary endpoints. Os monitores podem terminar a execução quando uma condição é satisfeita, ou outra função pode usar o cliente de orquestração durável para terminar os monitores.The monitors can end execution when a condition is met, or another function can use the durable orchestration client to terminate the monitors. Pode alterar o intervalo de um monitor wait com base numa condição específica (por exemplo, recuo exponencial.)You can change a monitor's wait interval based on a specific condition (for example, exponential backoff.)

O seguinte código implementa um monitor básico:The following code implements a basic monitor:

[FunctionName("MonitorJobStatus")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    int jobId = context.GetInput<int>();
    int pollingInterval = GetPollingInterval();
    DateTime expiryTime = GetExpiryTime();

    while (context.CurrentUtcDateTime < expiryTime)
    {
        var jobStatus = await context.CallActivityAsync<string>("GetJobStatus", jobId);
        if (jobStatus == "Completed")
        {
            // Perform an action when a condition is met.
            await context.CallActivityAsync("SendAlert", machineId);
            break;
        }

        // Orchestration sleeps until this time.
        var nextCheck = context.CurrentUtcDateTime.AddSeconds(pollingInterval);
        await context.CreateTimer(nextCheck, CancellationToken.None);
    }

    // Perform more work here, or let the orchestration end.
}

Quando um pedido é recebido, uma nova instância de orquestração é criada para esse iD de trabalho.When a request is received, a new orchestration instance is created for that job ID. O caso sonda um estado até que uma condição seja satisfeita e o loop seja saído.The instance polls a status until a condition is met and the loop is exited. Um temporizador durável controla o intervalo de votação.A durable timer controls the polling interval. Então, mais trabalho pode ser realizado, ou a orquestração pode terminar.Then, more work can be performed, or the orchestration can end. Quando nextCheck expiryTime exceder, o monitor termina.When nextCheck exceeds expiryTime, the monitor ends.

Padrão #5: Interação humanaPattern #5: Human interaction

Muitos processos automatizados envolvem algum tipo de interação humana.Many automated processes involve some kind of human interaction. Envolver humanos num processo automatizado é complicado porque as pessoas não estão tão disponíveis e tão responsivas como serviços na nuvem.Involving humans in an automated process is tricky because people aren't as highly available and as responsive as cloud services. Um processo automatizado pode permitir esta interação utilizando intervalos de tempo e lógica de compensação.An automated process might allow for this interaction by using timeouts and compensation logic.

Um processo de aprovação é um exemplo de um processo de negócio que envolve interação humana.An approval process is an example of a business process that involves human interaction. A aprovação de um gestor pode ser necessária para um relatório de despesas que exceda um determinado valor em dólares.Approval from a manager might be required for an expense report that exceeds a certain dollar amount. Se o gestor não aprovar o relatório de despesas dentro de 72 horas (talvez o gerente tenha ido de férias), um processo de escalada começa a receber a aprovação de outra pessoa (talvez o gerente).If the manager doesn't approve the expense report within 72 hours (maybe the manager went on vacation), an escalation process kicks in to get the approval from someone else (perhaps the manager's manager).

Um diagrama do padrão de interação humana

Pode implementar o padrão neste exemplo utilizando uma função orquestradora.You can implement the pattern in this example by using an orchestrator function. O orquestrador usa um temporizador durável para solicitar aprovação.The orchestrator uses a durable timer to request approval. O orquestrador aumenta se ocorrer tempo.The orchestrator escalates if timeout occurs. O orquestrador aguarda um evento externo, como uma notificação que é gerada por uma interação humana.The orchestrator waits for an external event, such as a notification that's generated by a human interaction.

Estes exemplos criam um processo de aprovação para demonstrar o padrão de interação humana:These examples create an approval process to demonstrate the human interaction pattern:

[FunctionName("ApprovalWorkflow")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    await context.CallActivityAsync("RequestApproval", null);
    using (var timeoutCts = new CancellationTokenSource())
    {
        DateTime dueTime = context.CurrentUtcDateTime.AddHours(72);
        Task durableTimeout = context.CreateTimer(dueTime, timeoutCts.Token);

        Task<bool> approvalEvent = context.WaitForExternalEvent<bool>("ApprovalEvent");
        if (approvalEvent == await Task.WhenAny(approvalEvent, durableTimeout))
        {
            timeoutCts.Cancel();
            await context.CallActivityAsync("ProcessApproval", approvalEvent.Result);
        }
        else
        {
            await context.CallActivityAsync("Escalate", null);
        }
    }
}

Para criar o temporizador durável, context.CreateTimer ligue.To create the durable timer, call context.CreateTimer. A notificação é recebida por context.WaitForExternalEvent .The notification is received by context.WaitForExternalEvent. Em seguida, Task.WhenAny é chamado a decidir se se agrava (o intervalo acontece primeiro) ou processa a aprovação (a aprovação é recebida antes do intervalo).Then, Task.WhenAny is called to decide whether to escalate (timeout happens first) or process the approval (the approval is received before timeout).

Um cliente externo pode entregar a notificação do evento a uma função de orquestrador de espera utilizando as APIs HTTP incorporadas:An external client can deliver the event notification to a waiting orchestrator function by using the built-in HTTP APIs:

curl -d "true" http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}/raiseEvent/ApprovalEvent -H "Content-Type: application/json"

Um evento também pode ser levantado usando o cliente de orquestração durável a partir de outra função na mesma aplicação de função:An event can also be raised using the durable orchestration client from another function in the same function app:

[FunctionName("RaiseEventToOrchestration")]
public static async Task Run(
    [HttpTrigger] string instanceId,
    [DurableClient] IDurableOrchestrationClient client)
{
    bool isApproved = true;
    await client.RaiseEventAsync(instanceId, "ApprovalEvent", isApproved);
}

Padrão #6: Agregador (entidades imponentes)Pattern #6: Aggregator (stateful entities)

O sexto padrão é sobre agregar dados de eventos durante um período de tempo numa única entidadeendereçada.The sixth pattern is about aggregating event data over a period of time into a single, addressable entity. Neste padrão, os dados agregados podem vir de múltiplas fontes, podem ser entregues em lotes, ou podem ser dispersos por longos períodos de tempo.In this pattern, the data being aggregated may come from multiple sources, may be delivered in batches, or may be scattered over long-periods of time. O agregador poderá ter de tomar medidas sobre os dados dos eventos à medida que chega, e os clientes externos podem precisar de consultar os dados agregados.The aggregator might need to take action on event data as it arrives, and external clients may need to query the aggregated data.

Diagrama agregador

O mais complicado de tentar implementar este padrão com funções normais e apátridas é que o controlo da conuncy torna-se um grande desafio.The tricky thing about trying to implement this pattern with normal, stateless functions is that concurrency control becomes a huge challenge. Não só precisa de se preocupar com vários fios que modificam os mesmos dados ao mesmo tempo, como também tem de se preocupar em garantir que o agregador só funciona num único VM de cada vez.Not only do you need to worry about multiple threads modifying the same data at the same time, you also need to worry about ensuring that the aggregator only runs on a single VM at a time.

Você pode usar entidades duráveis para implementar facilmente este padrão como uma única função.You can use Durable entities to easily implement this pattern as a single function.

[FunctionName("Counter")]
public static void Counter([EntityTrigger] IDurableEntityContext ctx)
{
    int currentValue = ctx.GetState<int>();
    switch (ctx.OperationName.ToLowerInvariant())
    {
        case "add":
            int amount = ctx.GetInput<int>();
            ctx.SetState(currentValue + amount);
            break;
        case "reset":
            ctx.SetState(0);
            break;
        case "get":
            ctx.Return(currentValue);
            break;
    }
}

Entidades duradouras também podem ser modeladas como classes em .NET.Durable entities can also be modeled as classes in .NET. Este modelo pode ser útil se a lista de operações for fixa e se tornar grande.This model can be useful if the list of operations is fixed and becomes large. O exemplo a seguir é uma implementação equivalente da Counter entidade utilizando classes e métodos .NET.The following example is an equivalent implementation of the Counter entity using .NET classes and methods.

public class Counter
{
    [JsonProperty("value")]
    public int CurrentValue { get; set; }

    public void Add(int amount) => this.CurrentValue += amount;

    public void Reset() => this.CurrentValue = 0;

    public int Get() => this.CurrentValue;

    [FunctionName(nameof(Counter))]
    public static Task Run([EntityTrigger] IDurableEntityContext ctx)
        => ctx.DispatchAsync<Counter>();
}

Os clientes podem enquadrizar operações para (também conhecida como "sinalização") uma função de entidade utilizando a ligação do cliente da entidade.Clients can enqueue operations for (also known as "signaling") an entity function using the entity client binding.

[FunctionName("EventHubTriggerCSharp")]
public static async Task Run(
    [EventHubTrigger("device-sensor-events")] EventData eventData,
    [DurableClient] IDurableOrchestrationClient entityClient)
{
    var metricType = (string)eventData.Properties["metric"];
    var delta = BitConverter.ToInt32(eventData.Body, eventData.Body.Offset);

    // The "Counter/{metricType}" entity is created on-demand.
    var entityId = new EntityId("Counter", metricType);
    await entityClient.SignalEntityAsync(entityId, "add", delta);
}

Nota

Os proxies gerados dinamicamente também estão disponíveis em .NET para entidades de sinalização de forma tipo segura.Dynamically generated proxies are also available in .NET for signaling entities in a type-safe way. Além da sinalização, os clientes também podem consultar o estado de uma função de entidade utilizando métodos de tipo seguro na ligação do cliente de orquestração.And in addition to signaling, clients can also query for the state of an entity function using type-safe methods on the orchestration client binding.

As funções de entidade estão disponíveis em Funções Duráveis 2.0 e superior para C# e JavaScript.Entity functions are available in Durable Functions 2.0 and above for C# and JavaScript.

A tecnologiaThe technology

Nos bastidores, a extensão de Funções Duradouras é construída em cima do Quadro de Tarefas Durable, uma biblioteca de código aberto no GitHub que é usada para construir fluxos de trabalho em código.Behind the scenes, the Durable Functions extension is built on top of the Durable Task Framework, an open-source library on GitHub that's used to build workflows in code. Tal como as Funções Azure é a evolução sem servidor do Azure WebJobs, as Funções Duradouras são a evolução sem servidor do Quadro de Tarefas Duráveis.Like Azure Functions is the serverless evolution of Azure WebJobs, Durable Functions is the serverless evolution of the Durable Task Framework. A Microsoft e outras organizações utilizam o Quadro de Tarefas Durable extensivamente para automatizar processos críticos da missão.Microsoft and other organizations use the Durable Task Framework extensively to automate mission-critical processes. É um ajuste natural para o ambiente Azure Functions sem servidor.It's a natural fit for the serverless Azure Functions environment.

Restrições de códigoCode constraints

A fim de fornecer garantias de execução fiáveis e de longa duração, as funções de orquestrador têm um conjunto de regras de codificação que devem ser seguidas.In order to provide reliable and long-running execution guarantees, orchestrator functions have a set of coding rules that must be followed. Para obter mais informações, consulte o artigo de restrições de função do Orquestrador.For more information, see the Orchestrator function code constraints article.

FaturaçãoBilling

As funções duradouras são faturadas da mesma forma que as Funções Azure.Durable Functions are billed the same as Azure Functions. Para obter mais informações, consulte os preços do Azure Functions.For more information, see Azure Functions pricing. Ao executar funções de orquestrador no planode consumo de funções Azure, existem alguns comportamentos de faturação a ter em conta.When executing orchestrator functions in the Azure Functions Consumption plan, there are some billing behaviors to be aware of. Para obter mais informações sobre estes comportamentos, consulte o artigo de faturação de Funções Duradouras.For more information on these behaviors, see the Durable Functions billing article.

Salta para dentroJump right in

Você pode começar com Funções Duráveis em menos de 10 minutos completando um destes tutoriais de arranque rápido específicos da linguagem:You can get started with Durable Functions in under 10 minutes by completing one of these language-specific quickstart tutorials:

Em ambos os arranques rápidos, você cria localmente e testa uma função durável "olá mundo".In both quickstarts, you locally create and test a "hello world" durable function. Em seguida, publique o código de função no Azure.You then publish the function code to Azure. A função que cria orquestra e acorrenta em conjunto chama a outras funções.The function you create orchestrates and chains together calls to other functions.

Saber maisLearn more

O seguinte vídeo destaca os benefícios das Funções Duradouras:The following video highlights the benefits of Durable Functions:

Para uma discussão mais aprofundada sobre as Funções Duradouras e a tecnologia subjacente, consulte o seguinte vídeo (está focado em .NET, mas os conceitos também se aplicam a outras línguas apoiadas):For a more in-depth discussion of Durable Functions and the underlying technology, see the following video (it's focused on .NET, but the concepts also apply to other supported languages):

Como as Funções Duradouras são uma extensão avançada para funções Azure,não é apropriado para todas as aplicações.Because Durable Functions is an advanced extension for Azure Functions, it isn't appropriate for all applications. Para uma comparação com outras tecnologias de orquestração Azure, consulte Compare Azure Functions e Azure Logic Apps.For a comparison with other Azure orchestration technologies, see Compare Azure Functions and Azure Logic Apps.

Passos seguintesNext steps