Présentation de Durable FunctionsWhat are Durable Functions?

Durable Functions est une extension d’Azure Functions qui vous permet d’écrire des fonctions avec état dans un environnement de calcul serverless.Durable Functions is an extension of Azure Functions that lets you write stateful functions in a serverless compute environment. L’extension vous permet de définir des workflows avec état en écrivant des fonctions orchestrator et des entités avec état en écrivant des fonctions d’entité à l’aide du modèle de programmation 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 arrière-plan, l’extension gère l’état, les points de contrôle et les redémarrages à votre place, ce qui vous permet de vous concentrer sur votre logique métier.Behind the scenes, the extension manages state, checkpoints, and restarts for you, allowing you to focus on your business logic.

Langages pris en chargeSupported languages

Durable Functions prend actuellement en charge les langages suivants :Durable Functions currently supports the following languages:

  • C#  : les bibliothèques de classes précompilées et le script C#.C#: both precompiled class libraries and C# script.
  • JavaScript : pris en charge uniquement pour la version 2.x du runtime Azure Functions.JavaScript: supported only for version 2.x of the Azure Functions runtime. Nécessite la version 1.7.0 ou ultérieure de l’extension Durable Functions.Requires version 1.7.0 of the Durable Functions extension, or a later version.
  • Python : nécessite la version 1.8.5 ou une version ultérieure de l’extension Durable Functions.Python: requires version 1.8.5 of the Durable Functions extension, or a later version.
  • F#  : les bibliothèques de classes précompilées et le script F#.F#: precompiled class libraries and F# script. Le script F# est pris en charge uniquement pour la version 1.x du runtime Azure Functions.F# script is only supported for version 1.x of the Azure Functions runtime.

À l’avenir, Durable Functions est censé prendre en charge tous les langages pris en charge dans Azure Functions.Durable Functions has a goal of supporting all Azure Functions languages. Consultez la liste des problèmes avec Durable Functions pour connaître l’état actuel de la prise en charge de langages supplémentaires.See the Durable Functions issues list for the latest status of work to support additional languages.

Comme dans Azure Functions, des modèles sont disponibles pour vous aider à développer des fonctions durables en utilisant Visual Studio 2019, Visual Studio Code et le portail Azure.Like Azure Functions, there are templates to help you develop Durable Functions using Visual Studio 2019, Visual Studio Code, and the Azure portal.

Modèles d’applicationApplication patterns

Le principal cas d’usage de Durable Functions est la simplification d’exigences complexes de coordination avec état dans des applications serverless.The primary use case for Durable Functions is simplifying complex, stateful coordination requirements in serverless applications. Les sections suivantes décrivent des modèles d’application standard qui peuvent tirer parti de Durable Functions :The following sections describe typical application patterns that can benefit from Durable Functions:

Modèle 1 : Chaînage de fonctionsPattern #1: Function chaining

Dans le modèle de chaînage de fonctions, une séquence de fonctions s’exécute dans un ordre spécifique.In the function chaining pattern, a sequence of functions executes in a specific order. Dans ce modèle, la sortie d’une fonction est appliquée à l’entrée d’une autre fonction.In this pattern, the output of one function is applied to the input of another function.

Schéma de modèle de chaînage de fonctions

Vous pouvez utiliser Durable Functions pour implémenter le modèle de chaînage de fonctions de façon concise, comme indiqué dans l’exemple ci-dessous.You can use Durable Functions to implement the function chaining pattern concisely as shown in the following example.

Dans cet exemple, les valeurs F1, F2, F3 et F4 représentent les noms d’autres fonctions dans la même application de fonction.In this example, the values F1, F2, F3, and F4 are the names of other functions in the same function app. Vous pouvez implémenter le flux de contrôle à l’aide de constructions de codage impératives normales.You can implement control flow by using normal imperative coding constructs. Le code s’exécute du haut vers le bas.Code executes from the top down. Le code peut impliquer une sémantique de flux contrôle de langage existante, notamment des instructions conditionnelles et des boucles.The code can involve existing language control flow semantics, like conditionals and loops. Vous pouvez inclure une logique de gestion des erreurs dans des blocs 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.
    }
}

Vous pouvez utiliser le paramètre context pour appeler d’autres fonctions par nom, passer des paramètres et retourner la sortie d’une fonction.You can use the context parameter to invoke other functions by name, pass parameters, and return function output. Chaque fois que le code appelle await, l’infrastructure Durable Functions crée des points de contrôle de la progression de l’instance de la fonction actuelle.Each time the code calls await, the Durable Functions framework checkpoints the progress of the current function instance. En cas de recyclage du processus ou de la machine virtuelle au milieu de l’exécution, l’instance de la fonction reprend à partir de l’appel await précédent.If the process or virtual machine recycles midway through the execution, the function instance resumes from the preceding await call. Pour en savoir plus, consultez la section suivante, Modèle 2 : Fan out/fan in.For more information, see the next section, Pattern #2: Fan out/fan in.

Modèle 2 : Fan out/fan inPattern #2: Fan out/fan in

Dans le modèle fan out/fan in, vous exécutez plusieurs fonctions en parallèle, puis attendez que toutes ces fonctions se terminent.In the fan out/fan in pattern, you execute multiple functions in parallel and then wait for all functions to finish. Un travail d’agrégation est souvent effectué sur les résultats retournés par les fonctions.Often, some aggregation work is done on the results that are returned from the functions.

Schéma du modèle fan out/fan in

Avec des fonctions normales, vous pouvez effectuer un processus fan out en configurant la fonction afin qu’elle envoie plusieurs messages vers une file d’attente.With normal functions, you can fan out by having the function send multiple messages to a queue. Mais le processus fan-in est beaucoup plus difficile.Fanning back in is much more challenging. Dans ce cas, dans une fonction normale, vous écrivez du code pour surveiller l’achèvement des fonctions déclenchées en file d’attente et stocker les sorties des fonctions.To fan in, in a normal function, you write code to track when the queue-triggered functions end, and then store function outputs.

L’extension Durable Functions gère ce modèle avec un code relativement simple :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);
}

Dans le cadre du processus fan-out, la distribution s’effectue vers plusieurs instances de la fonction F2.The fan-out work is distributed to multiple instances of the F2 function. Le travail est suivi à l’aide d’une liste de tâches dynamique.The work is tracked by using a dynamic list of tasks. Task.WhenAll est appelée pour attendre la fin de toutes les fonctions appelées.Task.WhenAll is called to wait for all the called functions to finish. Les sorties de la fonction F2 sont ensuite agrégées à partir de la liste de tâches dynamique puis transmises à la fonction F3.Then, the F2 function outputs are aggregated from the dynamic task list and passed to the F3 function.

La création automatique de points de contrôle qui a lieu lors de l’appel await sur Task.WhenAll garantit qu’un incident ou qu’un redémarrage potentiel survenu au milieu du processus ne nécessite pas le redémarrage d’une quelconque tâche déjà terminée.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.

Notes

Dans de rares circonstances, un plantage peut se produire dans la fenêtre après l’exécution d’une fonction d’activité, mais avant que son achèvement ne soit enregistré dans l’historique d’orchestration.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. Si cela se produit, la fonction d’activité s’exécute à nouveau depuis le début après la reprise du processus.If this happens, the activity function would re-run from the beginning after the process recovers.

Modèle 3 : API HTTP AsyncPattern #3: Async HTTP APIs

Le modèle d’API HTTP asynchrone traite le problème de coordination de l’état des opérations à exécution longue avec des clients externes.The async HTTP API pattern addresses the problem of coordinating the state of long-running operations with external clients. Pour implémenter ce modèle, une méthode courante consiste à faire déclencher l’action à exécution longue par un point de terminaison HTTP.A common way to implement this pattern is by having an HTTP endpoint trigger the long-running action. Le client est ensuite redirigé vers un point de terminaison d’état que le client interroge pour savoir quand l’opération est terminée.Then, redirect the client to a status endpoint that the client polls to learn when the operation is finished.

Schéma du modèle d’API HTTP

Durable Functions fournit une prise en charge intégrée pour ce modèle, en simplifiant ou même en supprimant le code que vous devez écrire pour interagir avec des exécutions de fonctions de longue durée.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. Ainsi, les exemples de démarrage rapide de Durable Functions (C# et JavaScript) montrent une commande REST simple qui vous permet de démarrer de nouvelles instances de fonctions orchestrator.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. Lorsqu’une instance démarre, l’extension expose des API HTTP webhook qui interrogent l’état de la fonction d’orchestrateur.After an instance starts, the extension exposes webhook HTTP APIs that query the orchestrator function status.

L’exemple suivant montre les commandes REST permettant de démarrer un orchestrateur et d’interroger son état.The following example shows REST commands that start an orchestrator and query its status. Par souci de clarté, certains détails du protocole ont été retirés de l’exemple.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", ...}

Étant donné que le runtime de Durable Functions gère l’état à votre place, vous n’avez pas besoin d’implémenter votre propre mécanisme de suivi de l’état.Because the Durable Functions runtime manages state for you, you don't need to implement your own status-tracking mechanism.

L’extension Durable Functions expose des API HTTP intégrées qui gèrent les orchestrations à exécution longue.The Durable Functions extension exposes built-in HTTP APIs that manage long-running orchestrations. Vous pouvez également implémenter ce modèle vous-même à l’aide de vos propres déclencheurs de fonction (comme un déclencheur HTTP, une file d’attente ou Azure Event Hubs) et de la liaison du client d’orchestration.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. Ainsi, vous pouvez utiliser un message de file d’attente pour déclencher l’arrêt.For example, you might use a queue message to trigger termination. Sinon, vous pouvez vous servir d’un déclencheur HTTP protégé par une stratégie d’authentification Azure Active Directory à la place des API HTTP intégrées qui utilisent une clé générée pour l’authentification.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.

Pour plus d’informations, consultez l’article Fonctionnalités HTTP, qui explique comment vous pouvez exposer des processus asynchrones à exécution longue sur HTTP à l’aide de l’extension 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.

Modèle 4 : SuperviserPattern #4: Monitor

Le modèle de surveillance fait référence à un processus souple et récurrent dans un flux de travail.The monitor pattern refers to a flexible, recurring process in a workflow. Il peut s’agir, par exemple, d’une interrogation se poursuivant jusqu’à ce que certaines conditions soient remplies.An example is polling until specific conditions are met. Vous pouvez utiliser un déclencheur de minuteur standard pour un scénario simple, comme une tâche de nettoyage périodique, mais son intervalle est statique et la gestion de la durée de vie des instances devient complexe.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. Vous pouvez utiliser Durable Functions pour créer des intervalles de récurrence flexibles, gérer la durée de vie des tâches et créer plusieurs processus de surveillance à partir d’une seule orchestration.You can use Durable Functions to create flexible recurrence intervals, manage task lifetimes, and create multiple monitor processes from a single orchestration.

L’inversion du scénario d’API HTTP asynchrone antérieur représente un exemple du modèle de surveillance.An example of the monitor pattern is to reverse the earlier async HTTP API scenario. Au lieu d’exposer un point de terminaison d’un client externe pour surveiller une opération longue, l’analyse de longue durée consomme un point de terminaison externe, puis attend un changement d’état.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.

Schéma du modèle de surveillance

Avec quelques lignes de code, vous pouvez utiliser Durable Functions pour créer plusieurs moniteurs qui observent des points de terminaison arbitraires.In a few lines of code, you can use Durable Functions to create multiple monitors that observe arbitrary endpoints. Les moniteurs peuvent mettre fin à une exécution lorsqu’une condition est remplie, ou une autre fonction peut utiliser le client d’orchestration durable pour arrêter les moniteurs.The monitors can end execution when a condition is met, or another function can use the durable orchestration client to terminate the monitors. Vous pouvez modifier l’intervalle wait d’un moniteur selon une condition spécifique (par exemple, avec un backoff exponentiel).You can change a monitor's wait interval based on a specific condition (for example, exponential backoff.)

Le code suivant implémente un moniteur de base :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.
}

Quand une requête est reçue, une nouvelle instance d’orchestration est créée pour cet ID de tâche.When a request is received, a new orchestration instance is created for that job ID. L’instance interroge un état jusqu’à ce qu’une condition soit respectée et que vous quittiez la boucle.The instance polls a status until a condition is met and the loop is exited. Un minuteur durable contrôle la fréquence d’interrogation.A durable timer controls the polling interval. Des opérations supplémentaires peuvent ensuite être exécutées, ou l’orchestration peut prendre fin.Then, more work can be performed, or the orchestration can end. Quand nextCheck dépasse expiryTime, le moniteur s’arrête.When nextCheck exceeds expiryTime, the monitor ends.

Modèle 5 : Interaction humainePattern #5: Human interaction

De nombreux processus automatisés impliquent un certain type d’interaction humaine.Many automated processes involve some kind of human interaction. L’implication de personnes humaines dans un processus automatisé est complexe, car elles ne sont pas toujours aussi disponibles et réactives que les services cloud.Involving humans in an automated process is tricky because people aren't as highly available and as responsive as cloud services. Un processus automatisé peut rendre cette interaction possible en utilisant des délais d’expiration et une logique de compensation.An automated process might allow for this interaction by using timeouts and compensation logic.

Un processus d’approbation est un exemple de processus d’entreprise impliquant une interaction humaine.An approval process is an example of a business process that involves human interaction. L’approbation d’un manager peut être requise si une note de frais dépasse un certain montant.Approval from a manager might be required for an expense report that exceeds a certain dollar amount. Si le manager n’approuve pas cette note de frais sous 72 heures (par exemple, s’il est en vacances), un processus d’escalade est déclenché pour obtenir l’approbation d’une autre personne (par exemple, le supérieur hiérarchique de ce manager).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).

Schéma du modèle d’interaction humaine

Vous pouvez implémenter le modèle utilisé dans cet exemple à l’aide d’une fonction d’orchestrateur.You can implement the pattern in this example by using an orchestrator function. L’orchestrateur utilise un minuteur durable pour demander l’approbation.The orchestrator uses a durable timer to request approval. L’orchestrateur procède à l’escalade si le délai d’expiration est atteint.The orchestrator escalates if timeout occurs. L’orchestrateur attend un événement externe, par exemple une notification générée par une interaction humaine.The orchestrator waits for an external event, such as a notification that's generated by a human interaction.

Les exemples suivants créent un processus d’approbation illustrant le modèle d’interaction humaine :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);
        }
    }
}

Pour créer le minuteur durable, appelez context.CreateTimer.To create the durable timer, call context.CreateTimer. La notification est reçue par context.WaitForExternalEvent.The notification is received by context.WaitForExternalEvent. Ensuite, Task.WhenAny est appelée pour déterminer s’il faut procéder à l’escalade (le délai d’expiration est atteint en premier) ou traiter l’approbation (l’approbation est reçue avant l’expiration du délai).Then, Task.WhenAny is called to decide whether to escalate (timeout happens first) or process the approval (the approval is received before timeout).

Un client externe peut remettre la notification d’événement à une fonction d’orchestrateur en attente au moyen d’API HTTP intégrées :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"

Un événement peut également être déclenché à l’aide du client d’orchestration durable à partir d’une autre fonction dans la même application de fonction :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);
}

Modèle 6 : Agrégateur (entités avec état)Pattern #6: Aggregator (stateful entities)

Le sixième modèle repose sur l’agrégation de données d’événement sur une période au sein d’une seule entité adressable.The sixth pattern is about aggregating event data over a period of time into a single, addressable entity. Dans ce modèle, les données agrégées peuvent provenir de plusieurs sources, être transmises par lots ou être dispersées sur de longues périodes.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. L’agrégateur devra peut-être effectuer une action sur les données d’événement à leur arrivée, et des clients externes devront peut-être interroger les données agrégées.The aggregator might need to take action on event data as it arrives, and external clients may need to query the aggregated data.

Schéma de l’agrégateur

L’implémentation de ce modèle avec des fonctions normales sans état fait naître un défi de taille : le contrôle d’accès concurrentiel.The tricky thing about trying to implement this pattern with normal, stateless functions is that concurrency control becomes a huge challenge. Vous devrez non seulement vous soucier du risque de modification des mêmes données par plusieurs threads au même moment, mais également veiller à ce que l’agrégateur s’exécute sur une seule machine virtuelle à la fois.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.

Vous pouvez utiliser des entités durables pour implémenter facilement ce modèle en tant que fonction unique.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;
    }
}

Les entités durables peuvent également être modélisées en tant que classes dans .NET.Durable entities can also be modeled as classes in .NET. Ce modèle peut être utile si la liste des opérations est fixe et devient volumineuse.This model can be useful if the list of operations is fixed and becomes large. L’exemple suivant est une implémentation équivalente de l’entité Counter à l’aide de classes et de méthodes .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>();
}

Les clients peuvent empiler les opérations dans le cadre d’une fonction d’entité (processus également appelé « signalisation ») à l’aide de la liaison du client d’entité.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);
}

Notes

Les proxies générés dynamiquement sont également disponibles dans .NET pour signaler les entités de type sécurisé.Dynamically generated proxies are also available in .NET for signaling entities in a type-safe way. En plus de la signalisation, les clients peuvent aussi interroger l’état d’une fonction d’entité à l’aide de méthodes de type sécurisé sur la liaison du client d’orchestration.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.

Les fonctions d’entité sont disponibles dans Durable Functions 2.0 et les versions ultérieures pour C# et JavaScript.Entity functions are available in Durable Functions 2.0 and above for C# and JavaScript.

La technologieThe technology

En arrière-plan, l’extension Durable Functions repose sur le Framework Durable Task, une bibliothèque open source sur GitHub utilisée pour la génération de workflows dans le code.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. Tout comme Azure Functions est l’évolution serverless d’Azure WebJobs, Durable Functions est l’évolution serverless de l’infrastructure 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 et d’autres organisations utilisent couramment l’infrastructure Durable Task Framework pour automatiser les processus critiques.Microsoft and other organizations use the Durable Task Framework extensively to automate mission-critical processes. Il convient parfaitement à l’environnement Azure Functions sans serveur.It's a natural fit for the serverless Azure Functions environment.

Contraintes du codeCode constraints

Pour pouvoir fournir des garanties d’exécution longue et fiable, les fonctions orchestrator possèdent un ensemble de règles de codage qui doivent être suivies.In order to provide reliable and long-running execution guarantees, orchestrator functions have a set of coding rules that must be followed. Pour plus d’informations, consultez l’article Contraintes du code des fonctions orchestrator.For more information, see the Orchestrator function code constraints article.

FacturationBilling

Durable Functions suit le même modèle de facturation qu’Azure Functions.Durable Functions are billed the same as Azure Functions. Pour plus d’informations, consultez Tarification d’Azure Functions.For more information, see Azure Functions pricing. Lors de l’exécution de fonctions orchestrator dans le plan de consommation Azure Functions, il est nécessaire de connaître certains comportements de facturation.When executing orchestrator functions in the Azure Functions Consumption plan, there are some billing behaviors to be aware of. Pour plus d’informations sur ces comportements, consultez l’article Facturation Durable Functions.For more information on these behaviors, see the Durable Functions billing article.

Démarrage rapideJump right in

Vous pouvez démarrer avec Durable Functions en moins de dix minutes en suivant l’un de ces tutoriels de démarrage rapide propres à chaque langage :You can get started with Durable Functions in under 10 minutes by completing one of these language-specific quickstart tutorials:

Dans les deux guides de démarrage rapide, vous créez et testez localement une fonction durable « hello world ».In both quickstarts, you locally create and test a "hello world" durable function. Vous allez ensuite publier le code de la fonction dans Azure.You then publish the function code to Azure. La fonction que vous créez orchestre et chaîne des appels à d’autres fonctions.The function you create orchestrates and chains together calls to other functions.

En savoir plusLearn more

La vidéo suivante présente les avantages d’utiliser Durable Functions :The following video highlights the benefits of Durable Functions:

Pour obtenir une discussion plus approfondie sur Durable Functions et la technologie sous-jacente, regardez la vidéo suivante (elle est consacrée à .NET, mais les concepts s’appliquent également à d’autres langages prises en charge) :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 est une extension avancée d’Azure Functions et ne convient donc pas à toutes les applications.Because Durable Functions is an advanced extension for Azure Functions, it isn't appropriate for all applications. Pour une comparaison avec d’autres technologies d’orchestration Azure, consultez Comparer Azure Functions et Azure Logic Apps.For a comparison with other Azure orchestration technologies, see Compare Azure Functions and Azure Logic Apps.

Étapes suivantesNext steps