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

Article
08/25/2024

Utilisez Durable Functions, une fonctionnalité d’Azure Functions, pour écrire des fonctions avec état dans un environnement serverless. Durable Functions gère l’état, les points de contrôle et les redémarrages dans votre application.

Dans ce démarrage rapide, vous créez et vous testez une application Durable Functions « hello world » en Java.

L’application Durable Functions la plus simple a trois fonctions :

Fonction d’orchestrateur : un workflow qui orchestre d’autres fonctions.
Fonction d’activité : une fonction appelée par la fonction d’orchestrateur ; elle effectue un travail et retourne éventuellement une valeur.
Fonction de client : une fonction normale dans Azure qui démarre une fonction d’orchestrateur. Cet exemple utilise une fonction déclenchée par HTTP.

Ce démarrage rapide décrit différentes façons de créer cette application « hello world ». Utilisez le sélecteur en haut de la page pour définir votre approche préférée.

Prérequis

Pour effectuer ce démarrage rapide, les éléments suivants sont requis :

Le Kit de développement logiciel Java (JDK) version 8 ou ultérieure installé.
Apache Maven version 3.0 ou ultérieure installé.
La version la plus récente d’Azure Functions Core Tools.

Pour Azure Functions 4.x, Core Tools version 4.0.4915 ou ultérieure est requis.
Un outil de test HTTP qui garde vos données en sécurité. Pour plus d’informations, consultez Outils de test HTTP.
Un abonnement Azure. Pour utiliser Durable Functions, vous devez disposer d’un compte de stockage Azure.

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit Azure avant de commencer.

Ajouter les dépendances et plug-ins requis à votre projet

Ajoutez le code suivant à votre fichier pom.xml :

<properties>
  <azure.functions.maven.plugin.version>1.18.0</azure.functions.maven.plugin.version>
  <azure.functions.java.library.version>3.0.0</azure.functions.java.library.version>
  <durabletask.azure.functions>1.0.0</durabletask.azure.functions>
  <functionAppName>your-unique-app-name</functionAppName>
</properties>

<dependencies>
  <dependency>
    <groupId>com.microsoft.azure.functions</groupId>
    <artifactId>azure-functions-java-library</artifactId>
    <version>${azure.functions.java.library.version}</version>
  </dependency>
  <dependency>
    <groupId>com.microsoft</groupId>
    <artifactId>durabletask-azure-functions</artifactId>
    <version>${durabletask.azure.functions}</version>
  </dependency>
</dependencies>

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.8.1</version>
    </plugin>
    <plugin>
      <groupId>com.microsoft.azure</groupId>
      <artifactId>azure-functions-maven-plugin</artifactId>
      <version>${azure.functions.maven.plugin.version}</version>
      <configuration>
        <appName>${functionAppName}</appName>
        <resourceGroup>java-functions-group</resourceGroup>
        <appServicePlanName>java-functions-app-service-plan</appServicePlanName>
        <region>westus</region>
        <runtime>
          <os>windows</os>
          <javaVersion>11</javaVersion>
        </runtime>
        <appSettings>
          <property>
            <name>FUNCTIONS_EXTENSION_VERSION</name>
            <value>~4</value>
          </property>
        </appSettings>
      </configuration>
      <executions>
        <execution>
          <id>package-functions</id>
          <goals>
            <goal>package</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
    <plugin>
      <artifactId>maven-clean-plugin</artifactId>
      <version>3.1.0</version>
    </plugin>
  </plugins>
</build>

Ajouter les fichiers JSON requis

Ajoutez un fichier host.json au répertoire de votre projet. Le résultat doit ressembler à l’exemple suivant :

{
  "version": "2.0",
  "logging": {
    "logLevel": {
      "DurableTask.AzureStorage": "Warning",
      "DurableTask.Core": "Warning"
    }
  },
  "extensions": {
    "durableTask": {
      "hubName": "JavaTestHub"
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

Remarque

Il est important de noter que seul le bundle d’extension Azure Functions v4 a actuellement la prise en charge nécessaire pour Durable Functions pour Java. Durable Functions pour Java n’est pas pris en charge dans v3 et les offres groupées d’extensions précoces. Pour plus d’informations sur les offres groupées d’extensions, consultez la documentation relative aux offres groupées d’extensions.

Durable Functions a besoin d’un fournisseur de stockage pour stocker l’état d’exécution. Ajoutez un fichier local.settings.json au répertoire de votre projet pour configurer le fournisseur de stockage. Pour utiliser Stockage Azure comme fournisseur, définissez la valeur de AzureWebJobsStorage sur la chaîne de connexion de votre compte Stockage Azure :

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "<your storage account connection string>",
    "FUNCTIONS_WORKER_RUNTIME": "java"
  }
}

Créer vos fonctions

L’exemple de code suivant montre un exemple de base de chaque type de fonction :

import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;
import java.util.*;

import com.microsoft.durabletask.*;
import com.microsoft.durabletask.azurefunctions.DurableActivityTrigger;
import com.microsoft.durabletask.azurefunctions.DurableClientContext;
import com.microsoft.durabletask.azurefunctions.DurableClientInput;
import com.microsoft.durabletask.azurefunctions.DurableOrchestrationTrigger;

public class DurableFunctionsSample {
    /**
     * This HTTP-triggered function starts the orchestration.
     */
    @FunctionName("StartOrchestration")
    public HttpResponseMessage startOrchestration(
            @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
            final ExecutionContext context) {
        context.getLogger().info("Java HTTP trigger processed a request.");

        DurableTaskClient client = durableContext.getClient();
        String instanceId = client.scheduleNewOrchestrationInstance("Cities");
        context.getLogger().info("Created new Java orchestration with instance ID = " + instanceId);
        return durableContext.createCheckStatusResponse(request, instanceId);
    }

    /**
     * This is the orchestrator function, which can schedule activity functions, create durable timers,
     * or wait for external events in a way that's completely fault-tolerant.
     */
    @FunctionName("Cities")
    public String citiesOrchestrator(
            @DurableOrchestrationTrigger(name = "taskOrchestrationContext") TaskOrchestrationContext ctx) {
        String result = "";
        result += ctx.callActivity("Capitalize", "Tokyo", String.class).await() + ", ";
        result += ctx.callActivity("Capitalize", "London", String.class).await() + ", ";
        result += ctx.callActivity("Capitalize", "Seattle", String.class).await() + ", ";
        result += ctx.callActivity("Capitalize", "Austin", String.class).await();
        return result;
    }

    /**
     * This is the activity function that is invoked by the orchestrator function.
     */
    @FunctionName("Capitalize")
    public String capitalize(@DurableActivityTrigger(name = "name") String name, final ExecutionContext context) {
        context.getLogger().info("Capitalizing: " + name);
        return name.toUpperCase();
    }
}

Créer un projet local en utilisant la commande Maven

Exécutez la commande suivante pour générer un projet qui contient les fonctions de base d’une application Durable Functions :

mvn archetype:generate -DarchetypeGroupId=com.microsoft.azure -DarchetypeArtifactId=azure-functions-archetype -DarchetypeVersion=1.51 -Dtrigger=durablefunctions

mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DarchetypeVersion=1.51" "-Dtrigger=durablefunctions"

mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DarchetypeVersion=1.51" "-Dtrigger=durablefunctions"

En suivant les invites, saisissez les informations suivantes :

Prompt	Action
groupId	Entrez com.function.
artifactId	Entrez myDurableFunction.
version	Sélectionnez 1.0-SNAPSHOT.
package	Entrez com.function.
Y	Entrez O, puis sélectionnez Entrée pour confirmer.

Vous disposez maintenant d’un projet local avec les trois fonctions dans une application Durable Functions de base.

Vérifiez que com.microsoft:durabletask-azure-functions est défini comme dépendance dans votre fichier pom.xml.

Configurer le fournisseur de stockage back-end

Durable Functions a besoin d’un fournisseur de stockage pour stocker l’état d’exécution. Vous pouvez définir Stockage Azure comme fournisseur de stockage dans local.settings.json. Utilisez la chaîne de connexion de votre compte de stockage Azure comme valeur pour AzureWebJobsStorage, comme dans cet exemple :

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "<your storage account connection string>",
    "FUNCTIONS_WORKER_RUNTIME": "java"
  }
}

Créer votre projet local

Dans Visual Studio Code, sélectionnez F1 (ou Ctrl/Cmd+Maj+P) pour ouvrir la palette de commandes. À l’invite (>), entrez puis sélectionnez Azure Functions : Créer un projet.
Cliquez sur Parcourir. Dans la boîte de dialogue Sélectionner un dossier, accédez à un dossier à utiliser pour votre projet, puis choisissez Sélectionner.

En suivant les invites, saisissez les informations suivantes :

Prompt	Action
Sélectionner une langue	Sélectionnez Java.
Sélectionner une version de Java	Sélectionnez Java 8 ou ultérieur. Sélectionnez la version de Java sur laquelle vos fonctions s’exécutent dans Azure et une que vous avez vérifiée localement.
Fournir un ID de groupe	Entrez com.function.
Fournir un ID d’artefact	Entrez myDurableFunction.
Fournir une version	Entrez 1.0-SNAPSHOT.
Fournir un nom de package	Entrez com.function.
Fournir un nom d’application	Entrez myDurableFunction.
Sélectionner l’outil de génération pour le projet Java	Sélectionnez Maven.
Sélectionner la façon dont vous souhaitez ouvrir votre projet	Sélectionnez Ouvrir dans une nouvelle fenêtre.

Vous disposez maintenant d’un projet avec un exemple de fonction HTTP. Vous pouvez supprimer cette fonction si vous le souhaitez, car vous ajoutez les fonctions de base d’une application Durable Functions à l’étape suivante.

Ajouter des fonctions au projet

Dans la palette de commandes, entrez puis sélectionnez Azure Functions : Créer une fonction.
Pour Modifier le filtre de modèle, sélectionnez Tous.

En suivant les invites, saisissez les informations suivantes :

Prompt	Action
Sélectionner un modèle pour votre fonction	Sélectionnez DurableFunctionsOrchestration.
Fournir un nom de package	Entrez com.function.
Fournir un nom de fonction	Entrez DurableFunctionsOrchestrator.

Dans la boîte de dialogue, choisissez Sélectionner un compte de stockage pour configurer un compte de stockage, puis suivez les invites.

Les trois fonctions de base d’une application Durable Functions doivent maintenant être générées.

Configurer pom.xml et host.json

Ajoutez la dépendance suivante à votre fichier pom.xml :

<dependency>
  <groupId>com.microsoft</groupId>
  <artifactId>durabletask-azure-functions</artifactId>
  <version>1.0.0</version>
</dependency>

Ajoutez la propriété extensions à votre fichier host.json :

"extensions": { "durableTask": { "hubName": "JavaTestHub" }}

Tester la fonction en local

Azure Functions Core Tools vous permet d’exécuter un projet Azure Functions sur votre ordinateur de développement local.

Remarque

Durable Functions pour Java nécessite Azure Functions Core Tools version 4.0.4915 ou ultérieure. Vous pouvez voir la version installée en exécutant la commande func --version dans le terminal.

Si vous utilisez Visual Studio Code, ouvrez une nouvelle fenêtre de terminal et exécutez les commandes suivantes pour générer le projet :
```
mvn clean package
```
Exécutez ensuite la fonction durable :
```
mvn azure-functions:run
```
Dans le panneau Terminal, copiez le point de terminaison de l’URL de votre fonction déclenchée par HTTP.

Utilisez un outil de test HTTP pour envoyer une requête POST HTTP au point de terminaison d’URL.

La réponse doit être similaire à l’exemple suivant :

{
    "id": "d1b33a60-333f-4d6e-9ade-17a7020562a9",
    "purgeHistoryDeleteUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d1b33a60-333f-4d6e-9ade-17a7020562a9?code=ACCupah_QfGKo...",
    "sendEventPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d1b33a60-333f-4d6e-9ade-17a7020562a9/raiseEvent/{eventName}?code=ACCupah_QfGKo...",
    "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d1b33a60-333f-4d6e-9ade-17a7020562a9?code=ACCupah_QfGKo...",
    "terminatePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/d1b33a60-333f-4d6e-9ade-17a7020562a9/terminate?reason={text}&code=ACCupah_QfGKo..."
}

La réponse est le résultat initial de la fonction HTTP. Il vous permet de savoir que l’orchestration durable a démarré correctement. Elle n’affiche pas encore le résultat final de l’orchestration. La réponse contient plusieurs URL utiles. Pour le moment, interrogez l’état de l’orchestration.

Copiez la valeur de l’URL pour statusQueryGetUri, collez-la dans la barre d’adresse de votre navigateur, puis exécutez la requête. Autrement, vous pouvez continuer à utiliser l’outil de test HTTP pour émettre la requête GET.

La requête interroge l’instance d’orchestration pour obtenir l’état. Vous devez voir que l’instance s’est terminée, et qu’elle inclut les sorties ou les résultats de la fonction durable, comme dans cet exemple :
```
{
    "name": "Cities",
    "instanceId": "d1b33a60-333f-4d6e-9ade-17a7020562a9",
    "runtimeStatus": "Completed",
    "input": null,
    "customStatus": "",
    "output":"TOKYO, LONDON, SEATTLE, AUSTIN",
    "createdTime": "2022-12-12T05:00:02Z",
    "lastUpdatedTime": "2022-12-12T05:00:06Z"
}
```

Partager via

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

Prérequis

Ajouter les dépendances et plug-ins requis à votre projet

Ajouter les fichiers JSON requis

Créer vos fonctions

Créer un projet local en utilisant la commande Maven

Configurer le fournisseur de stockage back-end

Créer votre projet local

Ajouter des fonctions au projet

Configurer pom.xml et host.json

Tester la fonction en local

Commentaires

Ressources supplémentaires