Orchestrations durablesDurable Orchestrations

Durable Functions est une extension d’Azure Functions.Durable Functions is an extension of Azure Functions. Vous pouvez utiliser une fonction d’orchestrateur pour orchestrer l’exécution d’autres fonctions durables dans une application de fonction.You can use an orchestrator function to orchestrate the execution of other Durable functions within a function app. Les fonctions orchestrator présentent les caractéristiques suivantes :Orchestrator functions have the following characteristics:

  • Les fonctions orchestrator définissent les workflows de fonction à l’aide de code procédural.Orchestrator functions define function workflows using procedural code. Elles ne nécessitent aucun concepteur ou schéma déclaratif.No declarative schemas or designers are needed.
  • Les fonctions orchestrator peuvent appeler d’autres fonctions durables de façon synchrone et asynchrone.Orchestrator functions can call other durable functions synchronously and asynchronously. La sortie des fonctions appelées peut être enregistrée de façon fiable dans des variables locales.Output from called functions can be reliably saved to local variables.
  • Les fonctions orchestrator sont durables et fiables.Orchestrator functions are durable and reliable. La progression de l’exécution fait automatiquement l’objet d’un point de contrôle quand la fonction « attend » ou « est suspendue ».Execution progress is automatically checkpointed when the function "awaits" or "yields". L’état local n’est jamais perdu quand le processus est recyclé ou que la machine virtuelle redémarre.Local state is never lost when the process recycles or the VM reboots.
  • L’exécution des fonctions orchestrator peut être longue.Orchestrator functions can be long-running. La durée de vie totale d’une instance d’orchestration peut se calculer en secondes, en jours, en mois ou être sans fin.The total lifespan of an orchestration instance can be seconds, days, months, or never-ending.

Cet article vous donne une vue d’ensemble des fonctions orchestrator et explique comment elles peuvent vous aider à résoudre diverses difficultés que vous rencontrez lors du développement d’applications.This article gives you an overview of orchestrator functions and how they can help you solve various app development challenges. Si vous n’êtes pas déjà familiarisé avec les types de fonctions disponibles dans une application Durable Functions, lisez d’abord l’article Types de fonctions durables.If you are not already familiar with the types of functions available in a Durable Functions app, read the Durable Function types article first.

Identité d’orchestrationOrchestration identity

Chaque instance d’une orchestration dispose d’un identificateur d’instance (également appelé ID d’instance).Each instance of an orchestration has an instance identifier (also known as an instance ID). Par défaut, chaque ID d’instance est un GUID généré automatiquement.By default, each instance ID is an autogenerated GUID. Toutefois, les ID d’instance peuvent également être toute valeur de chaîne générée par l’utilisateur.However, instance IDs can also be any user-generated string value. Chaque ID d’instance d’orchestration doit être unique dans un hub de tâches.Each orchestration instance ID must be unique within a task hub.

Voici quelques règles concernant les ID d’instance :The following are some rules about instance IDs:

  • Les ID d’instance doivent comprendre entre 1 et 256 caractères.Instance IDs must be between 1 and 256 characters.
  • Les ID d’instance ne doivent pas commencer par @.Instance IDs must not start with @.
  • Les ID d’instance ne doivent pas contenir de caractères /, \, # ou ?.Instance IDs must not contain /, \, #, or ? characters.
  • Les ID d’instance ne doivent pas contenir de caractères de contrôle.Instance IDs must not contain control characters.

Notes

Il est généralement recommandé d’utiliser autant que possible des ID d’instance générés automatiquement.It is generally recommended to use autogenerated instance IDs whenever possible. Les ID d’instance générés par l’utilisateur sont destinés aux scénarios dans lesquels il existe un mappage un-à-un entre une instance d’orchestration et une entité externe propre à l’application, comme un bon de commande ou un document.User-generated instance IDs are intended for scenarios where there is a one-to-one mapping between an orchestration instance and some external application-specific entity, like a purchase order or a document.

L’ID d’instance d’une orchestration est un paramètre obligatoire pour la plupart des opérations de gestion des instances.An orchestration's instance ID is a required parameter for most instance management operations. Il est également important pour les diagnostics, comme la recherche dans les données de suivi d’orchestration dans Application Insights à des fins de résolution des problèmes ou d’analyse.They are also important for diagnostics, such as searching through orchestration tracking data in Application Insights for troubleshooting or analytics purposes. C’est pourquoi il est recommandé d’enregistrer les ID d’instance générés dans un emplacement externe (par exemple, une base de données ou dans des journaux d’application) où ils peuvent être facilement référencés ultérieurement.For this reason, it is recommended to save generated instance IDs to some external location (for example, a database or in application logs) where they can be easily referenced later.

FiabilitéReliability

Les fonctions d’orchestrateur conservent de façon fiable leur état d’exécution à l’aide du modèle de conception approvisionnement d’événements.Orchestrator functions reliably maintain their execution state by using the event sourcing design pattern. Au lieu de stocker directement l’état actuel d’une orchestration, le framework Durable Task utilise un magasin d’ajout uniquement pour enregistrer toute la série d’actions effectuées par l’orchestration de fonction.Instead of directly storing the current state of an orchestration, the Durable Task Framework uses an append-only store to record the full series of actions the function orchestration takes. Un magasin d’ajout uniquement présente de nombreux avantages par rapport au « vidage » de l’état d’exécution complet.An append-only store has many benefits compared to "dumping" the full runtime state. Ces avantages incluent l’amélioration des performances, de l’extensibilité et de la réactivité.Benefits include increased performance, scalability, and responsiveness. Vous bénéficiez aussi de la cohérence finale des données transactionnelles, ainsi que de pistes d’audit et d’un historique complets.You also get eventual consistency for transactional data and full audit trails and history. Les pistes d’audit permettent des actions de compensation fiables.The audit trails support reliable compensating actions.

Durable Functions utilise l’approvisionnement d’événements en toute transparence.Durable Functions uses event sourcing transparently. En coulisse, l’opérateur await (C#) ou yield (JavaScript/Python) d’une fonction d’orchestrateur repasse le contrôle du thread orchestrateur au répartiteur Durable Task Framework.Behind the scenes, the await (C#) or yield (JavaScript/Python) operator in an orchestrator function yields control of the orchestrator thread back to the Durable Task Framework dispatcher. Le répartiteur valide ensuite dans le stockage toutes les actions que la fonction d’orchestrateur a planifiées (par exemple, l’appel d’une ou plusieurs fonctions enfant ou la planification d’un minuteur durable).The dispatcher then commits any new actions that the orchestrator function scheduled (such as calling one or more child functions or scheduling a durable timer) to storage. L’action de validation transparente s’ajoute à l’historique d’exécution de l’instance d’orchestration.The transparent commit action appends to the execution history of the orchestration instance. L’historique est stocké dans une table de stockage.The history is stored in a storage table. L’action de validation ajoute ensuite des messages à une file d’attente pour planifier le travail réel.The commit action then adds messages to a queue to schedule the actual work. À ce stade, la fonction d’orchestrateur peut être déchargée de la mémoire.At this point, the orchestrator function can be unloaded from memory.

Lorsqu’une fonction d’orchestration reçoit plus de tâches à effectuer (par exemple, un message de réponse est reçu ou un minuteur durable expire), l’orchestrateur sort à nouveau de veille et réexécute toute la fonction depuis le début afin de reconstruire l’état local.When an orchestration function is given more work to do (for example, a response message is received or a durable timer expires), the orchestrator wakes up and re-executes the entire function from the start to rebuild the local state. Si, au cours de la réexécution, le code tente d’appeler une fonction (ou effectue toute autre tâche asynchrone), l’infrastructure Durable Task Framework consulte l’historique d’exécution de l’orchestration en cours.During the replay, if the code tries to call a function (or do any other async work), the Durable Task Framework consults the execution history of the current orchestration. Si elle constate que la fonction d’activité a déjà été exécutée et a produit un résultat, elle réexécute le résultat de cette fonction, et le code d’orchestrateur continue de s’exécuter.If it finds that the activity function has already executed and yielded a result, it replays that function's result and the orchestrator code continues to run. La réexécution se poursuit jusqu’à ce que le code de la fonction s’achève ou jusqu’à ce qu’il ait planifié une nouvelle tâche asynchrone.Replay continues until the function code is finished or until it has scheduled new async work.

Notes

Pour que le modèle de relecture fonctionne correctement et de manière fiable, le code de fonction orchestrator doit être déterministe.In order for the replay pattern to work correctly and reliably, orchestrator function code must be deterministic. Pour plus d’informations sur les restrictions de code pour les fonctions orchestrator, consultez la rubrique Contraintes du code des fonctions.For more information about code restrictions for orchestrator functions, see the orchestrator function code constraints topic.

Notes

Si une fonction orchestrator émet des messages de journal, le comportement de relecture peut provoquer l’émission de messages de journal en double.If an orchestrator function emits log messages, the replay behavior may cause duplicate log messages to be emitted. Consultez la rubrique Journalisation pour découvrir les causes de ce comportement et le techniques pour le contourner.See the Logging topic to learn more about why this behavior occurs and how to work around it.

Historique d’orchestrationOrchestration history

Le comportement de l’approvisionnement en événements du framework Durable Task est étroitement lié au code de fonction orchestrator que vous écrivez.The event-sourcing behavior of the Durable Task Framework is closely coupled with the orchestrator function code you write. Supposons que vous disposez d’une fonction orchestrateur de chaînage d’activités, comme la fonction d’orchestrateur suivante :Suppose you have an activity-chaining orchestrator function, like the following orchestrator function:

[FunctionName("E1_HelloSequence")]
public static async Task<List<string>> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var outputs = new List<string>();

    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "Tokyo"));
    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "Seattle"));
    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "London"));

    // returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
    return outputs;
}

À chaque instruction await (C#) ou yield (JavaScript/Python), Durable Task Framework crée un point de contrôle de l’état d’exécution de la fonction dans un back-end de stockage durable (généralement le Stockage Table Azure).At each await (C#) or yield (JavaScript/Python) statement, the Durable Task Framework checkpoints the execution state of the function into some durable storage backend (typically Azure Table storage). Cet état est appelé historique d’orchestration.This state is what is referred to as the orchestration history.

Table d’historiqueHistory table

En règle générale, Durable Task Framework réalise les tâches suivantes à chaque point de contrôle :Generally speaking, the Durable Task Framework does the following at each checkpoint:

  1. Il enregistre l’historique d’exécution dans des tables de stockage Azure.Saves execution history into Azure Storage tables.
  2. Il empile les messages pour les fonctions que l’orchestrateur souhaite appeler.Enqueues messages for functions the orchestrator wants to invoke.
  3. Il empile les messages pour l’orchestrateur lui-même — par exemple, les messages d’un minuteur durable.Enqueues messages for the orchestrator itself — for example, durable timer messages.

Une fois le point de contrôle terminé, la fonction d’orchestrateur peut être supprimée de la mémoire jusqu'à ce qu’elle ait de nouvelles tâches à réaliser.Once the checkpoint is complete, the orchestrator function is free to be removed from memory until there is more work for it to do.

Notes

Le stockage Azure ne fournit aucune garantie transactionnelle entre l’enregistrement des données dans le stockage de tables et les files d’attente.Azure Storage does not provide any transactional guarantees between saving data into table storage and queues. Pour gérer les erreurs, le fournisseur de stockage Fonctions durables utilise les modèles de cohérence éventuelle.To handle failures, the Durable Functions storage provider uses eventual consistency patterns. Ces modèles évitent la perte de données en cas d’incident ou de perte de connectivité au cours d’un point de contrôle.These patterns ensure that no data is lost if there is a crash or loss of connectivity in the middle of a checkpoint.

Une fois que vous avez terminé, l’historique de la fonction présentée précédemment ressemble au tableau suivant dans le Stockage Table Azure (présentation raccourcie à des fins d’illustration) :Upon completion, the history of the function shown earlier looks something like the following table in Azure Table Storage (abbreviated for illustration purposes):

PartitionKey (InstanceId)PartitionKey (InstanceId) Type d’événementEventType TimestampTimestamp EntréeInput NomName RésultatsResult StatutStatus
eaee885beaee885b ExecutionStartedExecutionStarted 2017-05-05T18:45:28.852Z2017-05-05T18:45:28.852Z nullnull E1_HelloSequenceE1_HelloSequence
eaee885beaee885b OrchestratorStartedOrchestratorStarted 2017-05-05T18:45:32.362Z2017-05-05T18:45:32.362Z
eaee885beaee885b TaskScheduledTaskScheduled 2017-05-05T18:45:32.670Z2017-05-05T18:45:32.670Z E1_SayHelloE1_SayHello
eaee885beaee885b OrchestratorCompletedOrchestratorCompleted 2017-05-05T18:45:32.670Z2017-05-05T18:45:32.670Z
eaee885beaee885b TaskCompletedTaskCompleted 2017-05-05T18:45:34.201Z2017-05-05T18:45:34.201Z """Hello Tokyo!""""""Hello Tokyo!"""
eaee885beaee885b OrchestratorStartedOrchestratorStarted 2017-05-05T18:45:34.232Z2017-05-05T18:45:34.232Z
eaee885beaee885b TaskScheduledTaskScheduled 2017-05-05T18:45:34.435Z2017-05-05T18:45:34.435Z E1_SayHelloE1_SayHello
eaee885beaee885b OrchestratorCompletedOrchestratorCompleted 2017-05-05T18:45:34.435Z2017-05-05T18:45:34.435Z
eaee885beaee885b TaskCompletedTaskCompleted 2017-05-05T18:45:34.763Z2017-05-05T18:45:34.763Z """Hello Seattle!""""""Hello Seattle!"""
eaee885beaee885b OrchestratorStartedOrchestratorStarted 2017-05-05T18:45:34.857Z2017-05-05T18:45:34.857Z
eaee885beaee885b TaskScheduledTaskScheduled 2017-05-05T18:45:34.857Z2017-05-05T18:45:34.857Z E1_SayHelloE1_SayHello
eaee885beaee885b OrchestratorCompletedOrchestratorCompleted 2017-05-05T18:45:34.857Z2017-05-05T18:45:34.857Z
eaee885beaee885b TaskCompletedTaskCompleted 2017-05-05T18:45:34.919Z2017-05-05T18:45:34.919Z """Hello London!""""""Hello London!"""
eaee885beaee885b OrchestratorStartedOrchestratorStarted 2017-05-05T18:45:35.032Z2017-05-05T18:45:35.032Z
eaee885beaee885b OrchestratorCompletedOrchestratorCompleted 2017-05-05T18:45:35.044Z2017-05-05T18:45:35.044Z
eaee885beaee885b ExecutionCompletedExecutionCompleted 2017-05-05T18:45:35.044Z2017-05-05T18:45:35.044Z "[""Hello Tokyo!"",""Hello Seattle!"",""Hello London!""]""[""Hello Tokyo!"",""Hello Seattle!"",""Hello London!""]" CompletedCompleted

Quelques remarques sur les valeurs de colonne :A few notes on the column values:

  • PartitionKey : contient l’ID d’instance de l’orchestration.PartitionKey: Contains the instance ID of the orchestration.
  • EventType : représente le type de l’événement.EventType: Represents the type of the event. qui peut être l’un des suivants :May be one of the following types:
    • OrchestrationStarted : la fonction orchestrator a repris après une expression await ou s’exécute pour la première fois.OrchestrationStarted: The orchestrator function resumed from an await or is running for the first time. La colonne Timestamp indique la valeur déterministe pour les API CurrentUtcDateTime (.NET), currentUtcDateTime (JavaScript) ou current_utc_datetime (Python).The Timestamp column is used to populate the deterministic value for the CurrentUtcDateTime (.NET), currentUtcDateTime (JavaScript), and current_utc_datetime (Python) APIs.
    • ExecutionStarted : la fonction orchestrator a commencé à s’exécuter pour la première fois.ExecutionStarted: The orchestrator function started executing for the first time. Cet événement contient également l’entrée de la fonction dans la colonne Input.This event also contains the function input in the Input column.
    • TaskScheduled : une fonction d’activité a été planifiée.TaskScheduled: An activity function was scheduled. Le nom de la fonction d’activité est indiqué dans la colonne Name.The name of the activity function is captured in the Name column.
    • TaskCompleted : une fonction d’activité s’est terminée.TaskCompleted: An activity function completed. Le résultat de la fonction se trouve dans la colonne Result.The result of the function is in the Result column.
    • TimerCreated : un minuteur durable a été créé.TimerCreated: A durable timer was created. La colonne FireAt contient l’heure UTC planifiée à laquelle le minuteur expire.The FireAt column contains the scheduled UTC time at which the timer expires.
    • TimerFired : un minuteur durable s’est déclenché.TimerFired: A durable timer fired.
    • EventRaised : un événement externe a été envoyé à l’instance d’orchestration.EventRaised: An external event was sent to the orchestration instance. La colonne Name indique le nom de l’événement et la colonne Input indique la charge utile de l’événement.The Name column captures the name of the event and the Input column captures the payload of the event.
    • OrchestratorCompleted : la fonction orchestrator a attendu.OrchestratorCompleted: The orchestrator function awaited.
    • ContinueAsNew : la fonction orchestrator s’est terminée et a redémarré avec un nouvel état.ContinueAsNew: The orchestrator function completed and restarted itself with new state. La colonne Result contient la valeur, qui est utilisée comme entrée dans l’instance redémarrée.The Result column contains the value, which is used as the input in the restarted instance.
    • ExecutionCompleted : la fonction orchestrator s’est exécutée entièrement (ou a échoué).ExecutionCompleted: The orchestrator function ran to completion (or failed). Les sorties de la fonction ou les détails de l’erreur sont stockés dans la colonne Result.The outputs of the function or the error details are stored in the Result column.
  • Timestamp : horodatage UTC de l’événement d’historique.Timestamp: The UTC timestamp of the history event.
  • Name : nom de la fonction qui a été appelée.Name: The name of the function that was invoked.
  • Entrée: entrée au format JSON de la fonction.Input: The JSON-formatted input of the function.
  • Result : sortie de la fonction ; autrement dit, sa valeur renvoyée.Result: The output of the function; that is, its return value.

Avertissement

Même si cette table est utile en tant qu’outil de débogage, vous ne devez pas en dépendre.While it's useful as a debugging tool, don't take any dependency on this table. Elle peut changer à mesure que l’extension Fonctions durables évolue.It may change as the Durable Functions extension evolves.

Chaque fois que la fonction reprend après une expression await (C#) ou yield (JavaScript/Python), Durable Task Framework réexécute la fonction d’orchestrateur depuis le début.Every time the function resumes from an await (C#) or yield (JavaScript/Python), the Durable Task Framework reruns the orchestrator function from scratch. À chaque réexécution, il consulte l’historique d’exécution pour déterminer si l’opération asynchrone en cours a eu lieu.On each rerun, it consults the execution history to determine whether the current async operation has taken place. Si l’opération a eu lieu, le framework réexécute immédiatement la sortie de cette opération et passe à l’expression await (C#) ou yield (JavaScript/Python) suivante.If the operation took place, the framework replays the output of that operation immediately and moves on to the next await (C#) or yield (JavaScript/Python). Ce processus se poursuit jusqu’à ce que tout l’historique ait été réexécuté.This process continues until the entire history has been replayed. Une fois l’historique actuel relu, les variables locales sont restaurées à leurs valeurs précédentes.Once the current history has been replayed, the local variables will have been restored to their previous values.

Fonctionnalités et modèlesFeatures and patterns

Les sections suivantes décrivent les fonctionnalités et les modèles de fonctions orchestrator.The next sections describe the features and patterns of orchestrator functions.

Orchestrations secondairesSub-orchestrations

Les fonctions orchestrator peuvent appeler des fonctions d’activité, mais aussi d’autres fonctions orchestrator.Orchestrator functions can call activity functions, but also other orchestrator functions. Par exemple, vous pouvez créer une orchestration plus grande à partir d’une bibliothèque de fonctions d’orchestrateur.For example, you can build a larger orchestration out of a library of orchestrator functions. Vous pouvez aussi exécuter en parallèle plusieurs instances d’une fonction d’orchestrateur.Or, you can run multiple instances of an orchestrator function in parallel.

Pour obtenir plus d’informations et des exemples, consultez l’article Orchestrations secondaires.For more information and for examples, see the Sub-orchestrations article.

Minuteurs durablesDurable timers

Les orchestrations peuvent planifier des minuteurs durables pour implémenter des retards ou configurer le traitement des délais d’expiration sur les actions asynchrones.Orchestrations can schedule durable timers to implement delays or to set up timeout handling on async actions. Utilisez les minuteurs durables dans les fonctions d’orchestrateur à la place de Thread.Sleep et Task.Delay (C#), de setTimeout() et setInterval() (JavaScript), ou de time.sleep() (Python).Use durable timers in orchestrator functions instead of Thread.Sleep and Task.Delay (C#), or setTimeout() and setInterval() (JavaScript), or time.sleep() (Python).

Pour obtenir plus d’informations et des exemples, consultez l’article Minuteurs durables.For more information and for examples, see the Durable timers article.

Événements externesExternal events

Les fonctions d’orchestrateur peuvent attendre des événements externes pour mettre à jour une instance d’orchestration.Orchestrator functions can wait for external events to update an orchestration instance. Cette fonctionnalité Durable Functions est souvent utile pour gérer l’interaction humaine ou d’autres rappels externes.This Durable Functions feature often is useful for handling a human interaction or other external callbacks.

Pour obtenir plus d’informations et des exemples, consultez l’article Événements externes.For more information and for examples, see the External events article.

Gestion des erreursError handling

Les fonctions orchestrator peuvent utiliser les fonctionnalités de gestion des erreurs du langage de programmation.Orchestrator functions can use the error-handling features of the programming language. Les modèles existants comme try/catch sont pris en charge dans le code d’orchestration.Existing patterns like try/catch are supported in orchestration code.

Les fonctions orchestrator peuvent également ajouter des stratégies de nouvelles tentatives à l’activité ou aux fonctions orchestrator secondaires qu’elles appellent.Orchestrator functions can also add retry policies to the activity or sub-orchestrator functions that they call. Si une fonction d’activité ou une fonction orchestrator secondaire échoue avec une exception, la stratégie de nouvelles tentatives spécifiée peut automatiquement retarder et retenter l’exécution autant de fois que vous l’aurez spécifié.If an activity or sub-orchestrator function fails with an exception, the specified retry policy can automatically delay and retry the execution up to a specified number of times.

Notes

S’il existe une exception non prise en charge dans une fonction orchestrator, l’instance d’orchestration se termine dans l’état Failed.If there is an unhandled exception in an orchestrator function, the orchestration instance will complete in a Failed state. Une instance d’orchestration ne peut pas être retentée une fois qu’elle a échoué.An orchestration instance cannot be retried once it has failed.

Pour obtenir plus d’informations et des exemples, consultez l’article Gestion des erreurs.For more information and for examples, see the Error handling article.

Sections critiques (Durable Functions 2.x, actuellement seulement pour .NET)Critical sections (Durable Functions 2.x, currently .NET only)

Les instances d’orchestration étant à thread unique, il n’est pas nécessaire de se soucier des conditions de concurrence dans une orchestration.Orchestration instances are single-threaded so it isn't necessary to worry about race conditions within an orchestration. Toutefois, des conditions de concurrence sont possibles quand les orchestrations interagissent avec des systèmes externes.However, race conditions are possible when orchestrations interact with external systems. Pour atténuer les conditions de concurrence en cas d’interaction avec des systèmes externes, les fonctions orchestrator peuvent définir des sections critiques à l’aide d’une méthode LockAsync dans .NET.To mitigate race conditions when interacting with external systems, orchestrator functions can define critical sections using a LockAsync method in .NET.

L’exemple de code suivant illustre une fonction orchestrator qui définit une section critique.The following sample code shows an orchestrator function that defines a critical section. Elle entre la section critique à l’aide de la méthode LockAsync.It enters the critical section using the LockAsync method. Cette méthode nécessite de passer une ou plusieurs références à une entité durable, ce qui gère durablement l’état du verrou.This method requires passing one or more references to a Durable Entity, which durably manages the lock state. Une seule instance de cette orchestration peut exécuter le code de la section critique à la fois.Only a single instance of this orchestration can execute the code in the critical section at a time.

[FunctionName("Synchronize")]
public static async Task Synchronize(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var lockId = new EntityId("LockEntity", "MyLockIdentifier");
    using (await context.LockAsync(lockId))
    {
        // critical section - only one orchestration can enter at a time
    }
}

La méthode LockAsync acquiert un ou plusieurs verrous durables et retourne un IDisposable qui met fin à la section critique quand elle est supprimée.The LockAsync acquires the durable lock(s) and returns an IDisposable that ends the critical section when disposed. Ce résultat IDisposable peut être utilisé avec un bloc using pour obtenir une représentation syntaxique de la section critique.This IDisposable result can be used together with a using block to get a syntactic representation of the critical section. Quand une fonction orchestrator entre dans une section critique, une seule instance peut exécuter ce bloc de code.When an orchestrator function enters a critical section, only one instance can execute that block of code. Toutes les autres instances qui tentent d’entrer dans la section critique sont bloquées jusqu’à ce que l’instance précédente quitte la section critique.Any other instances that try to enter the critical section will be blocked until the previous instance exits the critical section.

La fonctionnalité de section critique est également utile pour coordonner les changements apportés à des entités durables.The critical section feature is also useful for coordinating changes to durable entities. Pour plus d’informations sur les sections critiques, consultez la rubrique « Coordination d’entités » (entités durables).For more information about critical sections, see the Durable entities "Entity coordination" topic.

Notes

Les sections critiques sont disponibles dans Durable Functions 2.0 et les versions ultérieures.Critical sections are available in Durable Functions 2.0 and above. Actuellement, seules les orchestrations .NET implémentent cette fonctionnalité.Currently, only .NET orchestrations implement this feature.

Appel de points de terminaison HTTP (Durable Functions 2.x)Calling HTTP endpoints (Durable Functions 2.x)

Les fonctions orchestrator ne sont pas autorisées à effectuer des E/S, comme décrit dans Contraintes du code des fonctions orchestrator.Orchestrator functions aren't permitted to do I/O, as described in orchestrator function code constraints. La solution de contournement classique de cette limitation consiste à wrapper dans une fonction d’activité tout code qui doit effectuer des E/S.The typical workaround for this limitation is to wrap any code that needs to do I/O in an activity function. Les orchestrations qui interagissent avec des systèmes externes utilisent fréquemment des fonctions d’activité pour effectuer des appels HTTP et retourner le résultat à l’orchestration.Orchestrations that interact with external systems frequently use activity functions to make HTTP calls and return the result to the orchestration.

Pour simplifier ce modèle courant, les fonctions d’orchestrateur peuvent utiliser la méthode CallHttpAsync pour appeler directement des API HTTP.To simplify this common pattern, orchestrator functions can use the CallHttpAsync method to invoke HTTP APIs directly.

[FunctionName("CheckSiteAvailable")]
public static async Task CheckSiteAvailable(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    Uri url = context.GetInput<Uri>();

    // Makes an HTTP GET request to the specified endpoint
    DurableHttpResponse response = 
        await context.CallHttpAsync(HttpMethod.Get, url);

    if (response.StatusCode >= 400)
    {
        // handling of error codes goes here
    }
}

En plus de prendre en charge les modèles de requête/réponse de base, la méthode prend en charge la gestion automatique des modèles d’interrogation HTTP 202 asynchrones courants ainsi que l’authentification avec des services externes en utilisant des identités managées.In addition to supporting basic request/response patterns, the method supports automatic handling of common async HTTP 202 polling patterns, and also supports authentication with external services using Managed Identities.

Pour obtenir plus d’informations et des exemples détaillés, consultez l’article Fonctionnalités HTTP.For more information and for detailed examples, see the HTTP features article.

Notes

L’appel des points de terminaison HTTP directement à partir de fonctions orchestrator est disponible dans Durable Functions 2.0 et les versions ultérieures.Calling HTTP endpoints directly from orchestrator functions is available in Durable Functions 2.0 and above.

Transmission de plusieurs paramètresPassing multiple parameters

Il n’est pas possible de passer directement plusieurs paramètres à une fonction d’activité.It isn't possible to pass multiple parameters to an activity function directly. La recommandation est de passer un tableau d’objets ou d’objets composites.The recommendation is to pass in an array of objects or composite objects.

Dans .NET, vous pouvez également utiliser des objets ValueTuple.In .NET you can also use ValueTuple objects. L’exemple suivant utilise de nouvelles fonctionnalités de ValueTuple ajoutées avec C# 7 :The following sample is using new features of ValueTuple added with C# 7:

[FunctionName("GetCourseRecommendations")]
public static async Task<object> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string major = "ComputerScience";
    int universityYear = context.GetInput<int>();

    object courseRecommendations = await context.CallActivityAsync<object>(
        "CourseRecommendations",
        (major, universityYear));
    return courseRecommendations;
}

[FunctionName("CourseRecommendations")]
public static async Task<object> Mapper([ActivityTrigger] IDurableActivityContext inputs)
{
    // parse input for student's major and year in university
    (string Major, int UniversityYear) studentInfo = inputs.GetInput<(string, int)>();

    // retrieve and return course recommendations by major and university year
    return new
    {
        major = studentInfo.Major,
        universityYear = studentInfo.UniversityYear,
        recommendedCourses = new []
        {
            "Introduction to .NET Programming",
            "Introduction to Linux",
            "Becoming an Entrepreneur"
        }
    };
}

Étapes suivantesNext steps