Partager via


Chaînage de fonctions dans Fonctions durables - Exemple de séquence Hello

Un chaînage de fonctions fait référence au modèle d’exécution d’une séquence de fonctions dans un ordre particulier. La sortie d’une fonction doit souvent être appliquée à l’entrée d’une autre fonction. Cet article décrit la séquence de chaînage que vous créez lorsque vous suivez le guide de démarrage rapide de Durable Functions (C#, JavaScript, TypeScript, Python, PowerShell ou Java). Pour plus d’informations sur Durable Functions, consultez Vue d’ensemble de Durable Functions.

Prérequis

Remarque

La version 4 du modèle de programmation Node.js pour Azure Functions est en disponibilité générale. Le nouveau modèle v4 est conçu pour offrir une expérience plus flexible et intuitive pour les développeurs JavaScript et TypeScript. En savoir plus sur les différences entre v3 et v4 dans le guide de migration.

Dans les extraits de code suivants, JavaScript (PM4) désigne le modèle de programmation V4, la nouvelle expérience.

Les fonctions

Cet article explique les fonctions suivantes dans l’exemple d’application :

  • E1_HelloSequence: Une fonction d’orchestrateur qui appelle E1_SayHello plusieurs fois dans une séquence. Il stocke les sorties à partir des appels de E1_SayHello et enregistre les résultats.
  • E1_SayHello: Une fonction d’activité qui fait précéder une chaîne de « Hello ».
  • HttpStart : Une fonction client durable déclenchée par HTTP qui démarre une instance de l’orchestrateur.

Fonction d’orchestrateur E1_HelloSequence

[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_DirectInput", "London"));

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

Toutes les fonctions d’orchestration C# doivent avoir un paramètre de type DurableOrchestrationContext, qui existe dans l’assembly Microsoft.Azure.WebJobs.Extensions.DurableTask. Cet objet de contexte vous permet d’appeler d’autres fonctions d’activité et de passer les paramètres d’entrée à l’aide de sa méthode CallActivityAsync.

Le code appelle trois fois E1_SayHello en séquence avec des valeurs de paramètre différentes. La valeur renvoyée de chaque appel est ajoutée à la liste outputs, qui est retournée à la fin de la fonction.

Fonction d’activité E1_SayHello

[FunctionName("E1_SayHello")]
public static string SayHello([ActivityTrigger] IDurableActivityContext context)
{
    string name = context.GetInput<string>();
    return $"Hello {name}!";
}

Les activités utilisent l’attribut ActivityTrigger. Utilisez la valeur IDurableActivityContext fournie pour effectuer des actions liées à l’activité, telles que l’accès à la valeur d’entrée à l’aide de GetInput<T>.

L’implémentation de E1_SayHello est une opération de mise en forme de chaîne relativement simple.

Au lieu de lier à une valeur IDurableActivityContext, vous pouvez établir une liaison directe au type passé dans la fonction d’activité. Par exemple :

[FunctionName("E1_SayHello_DirectInput")]
public static string SayHelloDirectInput([ActivityTrigger] string name)
{
    return $"Hello {name}!";
}

Fonction cliente HttpStart

Vous pouvez démarrer une instance de la fonction d’orchestrateur à l’aide d’une fonction cliente. Vous allez utiliser la fonction déclenchée par HTTP HttpStart pour démarrer des instances de E1_HelloSequence.

public static class HttpStart
{
    [FunctionName("HttpStart")]
    public static async Task<HttpResponseMessage> Run(
        [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}")] HttpRequestMessage req,
        [DurableClient] IDurableClient starter,
        string functionName,
        ILogger log)
    {
        // Function input comes from the request content.
        object eventData = await req.Content.ReadAsAsync<object>();
        string instanceId = await starter.StartNewAsync(functionName, eventData);

        log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

        return starter.CreateCheckStatusResponse(req, instanceId);
    }
}

Pour interagir avec des orchestrateurs, la fonction doit inclure une liaison d’entrée DurableClient. Vous utilisez le client pour démarrer une orchestration. Il peut également vous aider à retourner une réponse HTTP contenant des URL pour vérifier l’état de la nouvelle orchestration.

Exécution de l'exemple

Pour exécuter l’orchestration E1_HelloSequence, envoyez la requête HTTP POST suivante à la fonction HttpStart.

POST http://{host}/orchestrators/E1_HelloSequence

Notes

L’extrait de code HTTP précédent suppose qu’il existe une entrée dans le fichier host.json, qui supprime le préfixe api/ par défaut de toutes les URL de fonctions de déclencheur HTTP. Le balisage pour cette configuration figure dans le fichier host.json dans les exemples.

Par exemple, si vous exécutez l’exemple dans une application de fonction nommée « myfunctionapp », remplacez « {hôte} » par « myfunctionapp.azurewebsites.net ».

Le résultat est une réponse HTTP 202, comme celle-ci (ajustée par souci de concision) :

HTTP/1.1 202 Accepted
Content-Length: 719
Content-Type: application/json; charset=utf-8
Location: http://{host}/runtime/webhooks/durabletask/instances/96924899c16d43b08a536de376ac786b?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

(...trimmed...)

À ce stade, l’orchestration est mise en file d’attente et commence à s’exécuter immédiatement. L’URL dans l’en-tête Location peut être utilisée pour vérifier l’état de l’exécution.

GET http://{host}/runtime/webhooks/durabletask/instances/96924899c16d43b08a536de376ac786b?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

Le résultat est l'état de l'orchestration. Elle s’exécute et se termine rapidement, vous voyez donc le résultat dans l’état Terminé avec une réponse qui ressemble à ceci (ajustée par souci de concision) :

HTTP/1.1 200 OK
Content-Length: 179
Content-Type: application/json; charset=utf-8

{"runtimeStatus":"Completed","input":null,"output":["Hello Tokyo!","Hello Seattle!","Hello London!"],"createdTime":"2017-06-29T05:24:57Z","lastUpdatedTime":"2017-06-29T05:24:59Z"}

Comme vous pouvez le voir, le runtimeStatus de l’instance est Terminé et le output contient le résultat sérialisé en JSON de l’exécution de la fonction d’orchestration.

Notes

Vous pouvez implémenter une logique de démarrage similaire pour d’autres types de déclenchement, comme queueTrigger, eventHubTrigger, ou timerTrigger.

Examinez les journaux d’activité d’exécution de fonction. La fonction E1_HelloSequence a démarré et s’est terminée plusieurs fois en raison du comportement de relecture décrit dans la rubrique sur la fiabilité de l’orchestration. En revanche, il n’y a eu que trois exécutions de E1_SayHello étant donné que les exécutions de la fonction ne sont pas relues.

Étapes suivantes

Cet exemple a illustré une orchestration simple de chaînage de fonction. L’exemple suivant montre comment implémenter le modèle fan-out/fan-in.