¿Qué es Durable Functions?What are Durable Functions?

Durable Functions es una extensión de Azure Functions que permite escribir funciones con estado en un entorno de proceso sin servidor.Durable Functions is an extension of Azure Functions that lets you write stateful functions in a serverless compute environment. La extensión permite definir flujos de trabajo con estado mediante la escritura de funciones del orquestador y entidades con estado mediante la escritura de funciones de entidad con el modelo de programación de 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. En segundo plano, la extensión administra automáticamente el estado, los puntos de comprobación y los reinicios, lo que le permite centrarse en la lógica de negocios.Behind the scenes, the extension manages state, checkpoints, and restarts for you, allowing you to focus on your business logic.

Supported languages

Durable Functions admite actualmente los siguientes idiomas:Durable Functions currently supports the following languages:

  • C# : tanto las bibliotecas de clases precompiladas como script C#.C#: both precompiled class libraries and C# script.
  • JavaScript: solo es compatible con la versión 2.x del entorno de ejecución de Azure Functions.JavaScript: supported only for version 2.x of the Azure Functions runtime. Requiere la versión 1.7.0 de la extensión Durable Functions, o una posterior.Requires version 1.7.0 of the Durable Functions extension, or a later version.
  • Python: requiere la versión 1.8.5 de la extensión Durable Functions, o cualquier versión posterior.Python: requires version 1.8.5 of the Durable Functions extension, or a later version.
  • F# : tanto las bibliotecas de clases precompiladas como script F#.F#: precompiled class libraries and F# script. El script F# solo es compatible con la versión 1.x del entorno de ejecución de Azure Functions.F# script is only supported for version 1.x of the Azure Functions runtime.

Durable Functions tiene el objetivo de admitir todos los idiomas de Azure Functions.Durable Functions has a goal of supporting all Azure Functions languages. Consulte en la lista de problemas de Durable Functions en qué punto se encuentra la compatibilidad con idiomas adicionales.See the Durable Functions issues list for the latest status of work to support additional languages.

Al igual que con Azure Functions, existen plantillas que le ayudarán a desarrollar Durable Functions mediante Visual Studio 2019, Visual Studio Code y Azure Portal.Like Azure Functions, there are templates to help you develop Durable Functions using Visual Studio 2019, Visual Studio Code, and the Azure portal.

Patrones de aplicaciónApplication patterns

El caso de uso principal para Durable Functions es simplificar los requisitos de coordinación con estado complejos en las aplicaciones sin servidor.The primary use case for Durable Functions is simplifying complex, stateful coordination requirements in serverless applications. Las siguientes secciones describen patrones de aplicación típicos que se pueden beneficiar de Durable Functions:The following sections describe typical application patterns that can benefit from Durable Functions:

Patrón 1: Diagrama de encadenamiento de funcionesPattern #1: Function chaining

En el modelo de encadenamiento de funciones, una secuencia de funciones se ejecuta en un orden específico.In the function chaining pattern, a sequence of functions executes in a specific order. Con este patrón, la salida de una función se aplica a la entrada de otra función.In this pattern, the output of one function is applied to the input of another function.

Un diagrama del patrón de encadenamiento de funciones

Puede utilizar Durable Functions para implementar el patrón de encadenamiento de funciones de forma concisa, como se muestra en el siguiente ejemplo.You can use Durable Functions to implement the function chaining pattern concisely as shown in the following example.

En este ejemplo, los valores F1, F2, F3 y F4 son los nombres de otras funciones de la aplicación de funciones.In this example, the values F1, F2, F3, and F4 are the names of other functions in the same function app. Puede implementar el flujo de control mediante construcciones de código imperativas normales.You can implement control flow by using normal imperative coding constructs. El código se ejecuta de arriba hacia abajo.Code executes from the top down. y puede implicar semántica de flujo de control del lenguaje ya existente, como instrucciones condicionales y bucles.The code can involve existing language control flow semantics, like conditionals and loops. Puede incluir lógica de control de errores en bloques try/catch/finally.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.
    }
}

Puede usar el parámetro context para invocar otras funciones por nombre, pasar parámetros y devolver la salida de una función.You can use the context parameter to invoke other functions by name, pass parameters, and return function output. Cada vez que el código llama a await, el marco de Durable Functions establece puntos de control del progreso de la instancia actual de la función.Each time the code calls await, the Durable Functions framework checkpoints the progress of the current function instance. Si el proceso o la máquina virtual se reciclan a mitad de la ejecución, la instancia de la función se reanuda desde la llamada a await anterior.If the process or virtual machine recycles midway through the execution, the function instance resumes from the preceding await call. Para obtener más información, consulte la siguiente sección, Patrón 2: Distribución ramificada de entrada y salida.For more information, see the next section, Pattern #2: Fan out/fan in.

Patrón 2: distribución ramificada de entrada y salidaPattern #2: Fan out/fan in

En el patrón de distribución ramificada de salida y entrada, se ejecutan en paralelo varias funciones y después se espera a que todas finalicen.In the fan out/fan in pattern, you execute multiple functions in parallel and then wait for all functions to finish. A menudo se realiza algún trabajo de agregación en los resultados devueltos de las funciones.Often, some aggregation work is done on the results that are returned from the functions.

Un diagrama del patrón de distribución ramificada de entrada y salida

Con las funciones normales, puedes realizar la distribución ramificada de salida al hacer que la función envíe varios mensajes a una cola.With normal functions, you can fan out by having the function send multiple messages to a queue. La distribución ramificada de entrada es mucho más compleja.Fanning back in is much more challenging. Para realizarla en una función normal, escribe código para realizar un seguimiento de cuándo finalizan las funciones desencadenadas por la cola y después almacenar la salida de la función.To fan in, in a normal function, you write code to track when the queue-triggered functions end, and then store function outputs.

La extensión de Durable Functions controla este patrón con código relativamente sencillo: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);
}

El trabajo de distribución ramificada se distribuye en varias instancias de la función F2.The fan-out work is distributed to multiple instances of the F2 function. Se realiza un seguimiento del trabajo mediante una lista dinámica de las tareas.The work is tracked by using a dynamic list of tasks. Se llama a la Task.WhenAll para esperar a que todas las funciones llamadas finalicen.Task.WhenAll is called to wait for all the called functions to finish. Después, los resultados de la función F2 se agregan desde la lista de tareas dinámica y se pasan a la función F3.Then, the F2 function outputs are aggregated from the dynamic task list and passed to the F3 function.

La creación automática de puntos de control que se produce en la llamada a await en Task.WhenAll garantiza que cualquier posible bloqueo o reinicio a mitad del proceso no requiera que se reinicien las tareas ya completadas.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

En raras ocasiones es posible que se produzca un bloqueo en la ventana después de que se complete una función de actividad, pero antes de que su finalización se guarde en el historial de la orquestación.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. Em ese caso, la función de actividad se volvería a ejecutar desde el principio en cuanto se recuperara el proceso.If this happens, the activity function would re-run from the beginning after the process recovers.

Patrón 3: Las API de HTTP asincrónicoPattern #3: Async HTTP APIs

El patrón de las API HTTP asincrónico soluciona el problema de coordinar el estado de las operaciones de larga duración con los clientes externos.The async HTTP API pattern addresses the problem of coordinating the state of long-running operations with external clients. Una forma habitual de implementar este patrón es que un punto de conexión HTTP desencadene la acción de larga duración.A common way to implement this pattern is by having an HTTP endpoint trigger the long-running action. A continuación, el cliente se redirige a un punto de conexión de estado al que sondea para saber cuando finalice la operación.Then, redirect the client to a status endpoint that the client polls to learn when the operation is finished.

Un diagrama del modelo de API de HTTP

Durable Functions proporciona compatibilidad integrada con este patrón, lo que simplifica, o incluso elimina, el código que hay que escribir para interactuar con ejecuciones de funciones de larga duración.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 ejemplo, los ejemplos que se incluyen en el inicio rápido de Durable Functions (C# y JavaScript) muestran un comando REST simple que se puede usar para iniciar nuevas instancias de funciones del orquestador.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. Tras iniciar una instancia, la extensión expone las API de HTTP de webhook que consultan el estado de la función del orquestador.After an instance starts, the extension exposes webhook HTTP APIs that query the orchestrator function status.

En el ejemplo siguiente se muestran los comandos REST para iniciar un orquestador y consultar su estado.The following example shows REST commands that start an orchestrator and query its status. Para que el ejemplo se vea con mayor claridad se omiten algunos detalles del protocolo.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", ...}

Dado que el entorno en tiempo de ejecución de Durable Functions administra el estado, no es necesario que implemente su propio mecanismo de seguimiento del estado.Because the Durable Functions runtime manages state for you, you don't need to implement your own status-tracking mechanism.

La extensión Durable Functions expone las API HTTP integradas que administran orquestaciones de larga duración.The Durable Functions extension exposes built-in HTTP APIs that manage long-running orchestrations. Este patrón también lo puede implementar usted mismo si utiliza sus propios desencadenadores de función (por ejemplo, HTTP, una cola o Azure Event Hubs) y el enlace del cliente de orquestación.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 ejemplo, puede utilizar un mensaje de cola para desencadenar la terminación.For example, you might use a queue message to trigger termination. O bien puede usar un desencadenador de HTTP que esté protegido por una directiva de autenticación de Azure Active Directory, en lugar de las API HTTP integradas que utilizan una clave generada para la autenticación.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 más información, consulte el artículo acerca de las características de HTTP, en el que se explica cómo se pueden exponer procesos asincrónicos de larga duración a través de HTTP con la extensión Durable Functions.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.

Patrón 4: SupervisiónPattern #4: Monitor

El patrón de supervisión hace referencia a un proceso flexible y periódico en un flujo de trabajo.The monitor pattern refers to a flexible, recurring process in a workflow. Un ejemplo es el sondeo hasta que se cumplen condiciones específicas.An example is polling until specific conditions are met. Puede usar un desencadenador de temporizador normal para solucionar un escenario simple (como un trabajo de limpieza periódico), pero el intervalo es estático y resulta más difícil administrar los ciclos de vida de las instancias.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. Puede usar Durable Functions para crear intervalos de periodicidad flexible, administrar el ciclo de vida de las tareas y crear varios procesos de supervisión a partir de una única orquestación.You can use Durable Functions to create flexible recurrence intervals, manage task lifetimes, and create multiple monitor processes from a single orchestration.

Un ejemplo del patrón de supervisión es invertir el escenario anterior de la API de HTTP asincrónica.An example of the monitor pattern is to reverse the earlier async HTTP API scenario. En lugar de exponer un punto de conexión para que un cliente externo supervise una operación de larga duración, el monitor de larga duración consume el punto de conexión externo y espera algún cambio 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.

Un diagrama del patrón de supervisión

Con unas cuantas líneas de código, puede utilizar Durable Functions para crear varios monitores que observen puntos de conexión arbitrarios.In a few lines of code, you can use Durable Functions to create multiple monitors that observe arbitrary endpoints. Los monitores pueden finalizar la ejecución cuando se cumple una condición u otra función puede usar el cliente de orquestación durable para terminar los monitores.The monitors can end execution when a condition is met, or another function can use the durable orchestration client to terminate the monitors. Puede cambiar el intervalo de wait del monitor según una condición específica (por ejemplo, retroceso exponencial).You can change a monitor's wait interval based on a specific condition (for example, exponential backoff.)

El código siguiente implementa un 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.
}

Cuando se recibe una solicitud, se crea una nueva instancia de orquestación para ese identificador de trabajo.When a request is received, a new orchestration instance is created for that job ID. La instancia sondea un estado hasta que se cumple una condición y se cierra el bucle.The instance polls a status until a condition is met and the loop is exited. Un temporizador durable controla el intervalo de sondeo.A durable timer controls the polling interval. Después, se puede realizar trabajo adicional o puede finalizar la orquestación.Then, more work can be performed, or the orchestration can end. Cuando el valor de nextCheck supera el de expiryTime, el monitor finaliza.When nextCheck exceeds expiryTime, the monitor ends.

Patrón 5: Interacción humanaPattern #5: Human interaction

Muchos procesos automatizados implican algún tipo de interacción humana.Many automated processes involve some kind of human interaction. La intervención humana en un proceso automatizado es más difícil, ya que las personas no tienen la misma alta disponibilidad y capacidad de respuesta que los servicios en la nube.Involving humans in an automated process is tricky because people aren't as highly available and as responsive as cloud services. Los procesos automatizados pueden permitir esta interacción mediante el uso de tiempos de expiración y la lógica de compensación.An automated process might allow for this interaction by using timeouts and compensation logic.

Un proceso de aprobación es un ejemplo de un proceso empresarial que implica la interacción humana.An approval process is an example of a business process that involves human interaction. Para un informe de gastos que supera un importe en dólares determinado puede ser necesaria la aprobación de un administrador.Approval from a manager might be required for an expense report that exceeds a certain dollar amount. Si el administrador no aprueba el informe de gastos en un plazo de 72 horas (puede estar de vacaciones), se inicia un proceso de escalado para obtener la aprobación de otra persona (por ejemplo el jefe del administrador).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).

Un diagrama del patrón de interacción humana

Puede implementar el patrón en este ejemplo mediante una función de orquestador.You can implement the pattern in this example by using an orchestrator function. El orquestador usa un temporizador durable para solicitar la aprobación,The orchestrator uses a durable timer to request approval. y la escala si se agota el tiempo de espera.The orchestrator escalates if timeout occurs. El orquestador espera a que ocurra un evento externo, como una notificación generada por interacción humana.The orchestrator waits for an external event, such as a notification that's generated by a human interaction.

Estos ejemplos crean un proceso de aprobación para hacer una demostración del patrón de interacción 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 crear el temporizador durable, llame a context.CreateTimer.To create the durable timer, call context.CreateTimer. context.WaitForExternalEvent recibe la notificación.The notification is received by context.WaitForExternalEvent. Después, se realiza una llamada a Task.WhenAny para decidir si la aprobación se escala (primero se agota el tiempo de expiración) o se procesa (la aprobación antes se recibe de que se agote el tiempo de expiración).Then, Task.WhenAny is called to decide whether to escalate (timeout happens first) or process the approval (the approval is received before timeout).

Un cliente externo puede enviar la notificación de eventos a una función de orquestador en espera mediante las API HTTP integradas: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"

También se pueden generar eventos mediante el cliente de orquestación durable desde otra función de la misma aplicación de funciones: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);
}

Patrón 6: Agregador (entidades con estado)Pattern #6: Aggregator (stateful entities)

El sexto patrón se trata de agregar datos de eventos durante un período de tiempo en una solaentidad direccionable.The sixth pattern is about aggregating event data over a period of time into a single, addressable entity. En este patrón, los datos que se agreguen pueden proceder de varios orígenes, pueden entregarse en lotes o pueden estar dispersos en largos períodos de tiempo.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. Es posible que el agregador tome medidas según datos de eventos a medida que llegan, y puede que los clientes externos necesiten consultar los datos 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 de agregador

El aspecto más difícil de implementar este patrón con funciones normales sin estado es que el control de simultaneidad se convierte en un gran desafío.The tricky thing about trying to implement this pattern with normal, stateless functions is that concurrency control becomes a huge challenge. No solo es necesario preocuparse por varios subprocesos que modifican los mismos datos al mismo tiempo, también deberá preocuparse por garantizar que el agregador se ejecuta solo en una única VM a la 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.

Puede usar entidades duraderas para implementar fácilmente este patrón como una sola función.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;
    }
}

Las entidades duraderas también pueden modelarse como clases en .NET.Durable entities can also be modeled as classes in .NET. Este modelo puede ser útil si la lista de operaciones es fija y de gran tamaño.This model can be useful if the list of operations is fixed and becomes large. El ejemplo siguiente es una implementación equivalente de la entidad Counter que usa clases y 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>();
}

Los clientes pueden poner en cola las operaciones (también conocidas como "señalización") de una función de entidad mediante el enlace del cliente de la entidad.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

Los proxies generados dinámicamente también están disponibles en .NET para la señalización de entidades con seguridad de tipos.Dynamically generated proxies are also available in .NET for signaling entities in a type-safe way. Y, además de la señalización, los clientes también pueden consultar el estado de cualquier función de entidad mediante métodos con seguridad de tipos en el enlace del cliente de orquestación.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.

Las funciones de entidad están disponibles en Durable Functions 2.0 y versiones posteriores para C# y JavaScript.Entity functions are available in Durable Functions 2.0 and above for C# and JavaScript.

La tecnologíaThe technology

En segundo plano, la extensión Durable Functions se crea con Durable Task Framework, que es una biblioteca de código abierto que se encuentra en GitHub y se usa para crear flujos de trabajo en el 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. Así como Azure Functions es la evolución sin servidor de Azure WebJobs, Durable Functions es la evolución sin servidor de Durable Task Framework.Like Azure Functions is the serverless evolution of Azure WebJobs, Durable Functions is the serverless evolution of the Durable Task Framework. Microsoft y otras organizaciones utilizan Durable Task Framework ampliamente para automatizar los procesos críticos.Microsoft and other organizations use the Durable Task Framework extensively to automate mission-critical processes. Es una opción natural para el entorno de Azure Functions sin servidor.It's a natural fit for the serverless Azure Functions environment.

Restricciones del códigoCode constraints

Con el fin de proporcionar garantías de ejecución prolongada y confiable, las funciones del orquestador tienen un conjunto de reglas de codificación que deben seguirse.In order to provide reliable and long-running execution guarantees, orchestrator functions have a set of coding rules that must be followed. Para más información, consulte el artículo acerca de las restricciones del código de las funciones de Orchestrator.For more information, see the Orchestrator function code constraints article.

FacturaciónBilling

Durable Functions se factura igual que Azure Functions.Durable Functions are billed the same as Azure Functions. Para más información, consulte los precios de Azure Functions.For more information, see Azure Functions pricing. Al ejecutar funciones de orquestador en el plan de consumo de Azure Functions, hay algunos comportamientos de facturación que deben tenerse en cuenta.When executing orchestrator functions in the Azure Functions Consumption plan, there are some billing behaviors to be aware of. Para más información acerca de estos comportamientos, consulte el artículo en el que se explica la facturación de Durable Functions.For more information on these behaviors, see the Durable Functions billing article.

Comenzar de inmediatoJump right in

Puede empezar a trabajar con Durable Functions en menos de 10 minutos completando uno de estos tutoriales de inicio rápido específicos del idioma:You can get started with Durable Functions in under 10 minutes by completing one of these language-specific quickstart tutorials:

En ambos inicios rápidos, podrá crear y probar localmente una función durable de "hello world".In both quickstarts, you locally create and test a "hello world" durable function. Luego, publicará el código de función en Azure.You then publish the function code to Azure. La función que crea organiza y encadena llamadas a otras funciones.The function you create orchestrates and chains together calls to other functions.

Más informaciónLearn more

El siguiente vídeo resalta las ventajas de Durable Functions:The following video highlights the benefits of Durable Functions:

Para obtener una explicación más detallada tanto de Durable Functions como de su tecnología subyacente, vea el vídeo siguiente (en él se habla de .NET, pero los conceptos también se aplican a otros lenguajes admitidos):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):

Durable Functions es una extensión avanzada para Azure Functions que no es adecuada para todas las aplicaciones.Because Durable Functions is an advanced extension for Azure Functions, it isn't appropriate for all applications. Para obtener una comparación con otras tecnologías de orquestación de Azure, consulte Comparativa entre Azure Functions y Azure Logic Apps.For a comparison with other Azure orchestration technologies, see Compare Azure Functions and Azure Logic Apps.

Pasos siguientesNext steps