Démarrage rapide : Créer une application Durable Functions Java

Utilisez Durable Functions, une fonctionnalité de Azure Functions, pour écrire des flux de travail serverless avec état dans Java. Dans ce guide de démarrage rapide, vous clonez et exécutez un exemple d’application qui illustre deux modèles d’orchestration courants :

  • Chaînage de fonctions : appelle les activités de manière séquentielle (Tokyo → Seattle → Londres).
  • Fan-out/fan-in : appelle des activités en parallèle sur cinq villes, puis agrège les résultats.

À la fin, vous aurez exécuté localement les deux orchestrations avec l’émulateur Durable Task Scheduler et pourrez voir leur état dans le tableau de bord.

  • Clonez et préparez l’exemple de projet Hello Cities.
  • Configurez l’émulateur Durable Task Scheduler et Azurite pour le développement local.
  • Compilez et exécutez l’application de fonctions et déclenchez les deux orchestrations.
  • Consultez l’état et les résultats de l’orchestration dans le tableau de bord de Durable Task Scheduler.

Prerequisites

Configurer l’émulateur Durable Task Scheduler

L’émulateur Durable Task Scheduler fournit un environnement de développement local afin de pouvoir tester des orchestrations sans abonnement Azure. L’hôte Java Functions nécessite également Azurite pour le stockage local.

Démarrez les deux conteneurs :

docker run -d --name dtsemulator -p 8080:8080 -p 8082:8082 \
  mcr.microsoft.com/dts/dts-emulator:latest

docker run -d --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 \
  mcr.microsoft.com/azure-storage/azurite

Tip

Une fois l’émulateur en cours d’exécution, vous pouvez accéder au tableau de bord Durable Task Scheduler à l’adresse http://localhost:8082 pour surveiller les orchestrations.

Exécuter l’exemple de démarrage rapide

  1. Accédez à l’exemple de répertoire Hello Cities :

    cd samples/durable-functions/java/HelloCities

  2. Vérifiez que le local.settings.json fichier contient la configuration suivante :

    {
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "java",
    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
  }
}

  3. Construisez le projet :

    mvn clean package

  4. Démarrez l’application de fonctions :

    mvn azure-functions:run

  5. Dans un terminal distinct, déclenchez l’orchestration de chaînage de fonctions :

    $response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartChaining
$response

    La réponse contient des URL d’état pour l’instance d’orchestration. Copiez la valeur et exécutez-la statusQueryGetUri pour vérifier le résultat :

    Invoke-RestMethod -Uri $response.statusQueryGetUri

  6. Déclenchez l’orchestration fan-out/fan-in :

    $response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartFanOutFanIn
Invoke-RestMethod -Uri $response.statusQueryGetUri

Sortie attendue

La requête POST retourne une réponse JSON avec des URL d’état. Par exemple:

{
  "id": "<instanceId>",
  "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/<instanceId>?code=...",
  "sendEventPostUri": "...",
  "terminatePostUri": "...",
  "purgeHistoryDeleteUri": "..."
}

Lorsque vous interrogez statusQueryGetUri et que le runtimeStatus de l’orchestration est Completed, vous trouverez les résultats du message d’accueil dans le champ output. L’orchestration en chaîne renvoie :

{
  "name": "ChainingOrchestration",
  "runtimeStatus": "Completed",
  "output": "Hello Tokyo! Hello Seattle! Hello London!"
}

L’orchestration fan-out/fan-in renvoie :

{
  "name": "FanOutFanInOrchestration",
  "runtimeStatus": "Completed",
  "output": ["Hello Tokyo!", "Hello Seattle!", "Hello London!", "Hello Paris!", "Hello Berlin!"]
}

Tip

Si runtimeStatus affiche Running ou Pending, attendez un instant et interrogez de nouveau statusQueryGetUri.

Ouvrez le tableau de bord Durable Task Scheduler à l’adresse http://localhost:8082 pour afficher l’état de l’orchestration et l’historique d’exécution.

Comprendre le code

L’exemple de projet dans src/main/java/com/example/Functions.java contient les trois types de fonctions nécessaires pour une application Durable Functions.

Fonction d’activité

L’activité SayHello prend un nom de ville et retourne un message d’accueil :

@FunctionName("SayHello")
public String sayHello(
        @DurableActivityTrigger(name = "city") String city) {
    return "Hello " + city + "!";
}

Fonctions d’orchestrateur

L’orchestrateur de chaînage appelle SayHello de manière séquentielle pour trois villes :

@FunctionName("ChainingOrchestration")
public String chainingOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {

    String result = "";
    result += ctx.callActivity("SayHello", "Tokyo", String.class).await();
    result += " " + ctx.callActivity("SayHello", "Seattle", String.class).await();
    result += " " + ctx.callActivity("SayHello", "London", String.class).await();
    return result;
}

L’orchestrateur fan-out/fan-in planifie les activités en parallèle :

@FunctionName("FanOutFanInOrchestration")
public List<String> fanOutFanInOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {

    String[] cities = {"Tokyo", "Seattle", "London", "Paris", "Berlin"};
    List<Task<String>> parallelTasks = new ArrayList<>();

    for (String city : cities) {
        parallelTasks.add(ctx.callActivity("SayHello", city, String.class));
    }

    List<String> results = new ArrayList<>();
    for (Task<String> task : parallelTasks) {
        results.add(task.await());
    }

    return results;
}

Fonctions du client

Les fonctions clientes déclenchées par HTTP démarrent chaque orchestration :

@FunctionName("StartChaining")
public HttpResponseMessage startChaining(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Void> request,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {

    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance("ChainingOrchestration");
    return durableContext.createCheckStatusResponse(request, instanceId);
}

Configuration

L’exemple utilise l’émulateur Durable Task Scheduler comme back-end de stockage. Ceci est configuré dans host.json:

{
  "extensions": {
    "durableTask": {
      "hubName": "default",
      "storageProvider": {
        "type": "azureManaged",
        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
      }
    }
  }
}

La chaîne de connexion de l’émulateur est définie dans local.settings.json :

{
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "java",
    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
  }
}

Nettoyer les ressources

Arrêtez les conteneurs de l’émulateur lorsque vous avez terminé :

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Étapes suivantes

  • Last updated on