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

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

Ajoutez le code suivant à votre fichier pom.xml . Avant de le copier, remplacez your-unique-app-name par un nom d’application de fonction globalement unique. Ajustez region, javaVersionet resourceGroup pour correspondre à votre environnement.

<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)"
  }
}

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 d’orchestrateur, d’activité et de client Durable Functions

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 Durable Functions local à l’aide de 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.62 -Dtrigger=durablefunctions

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

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

En suivant les invites, saisissez les informations suivantes :

Vous disposez maintenant d’un projet local avec les trois fonctions dans une application Durable Functions de base. L’archétype inclut com.microsoft:durabletask-azure-functions automatiquement comme dépendance dans votre fichier pom.xml .

Configurer le fournisseur de stockage principal pour Durable Functions

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

1. 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.

   

2. 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.

3. En suivant les invites, saisissez les informations suivantes :

   Prompt	Action
   Sélectionner un langage	Sélectionnez Java.
   Sélectionnez 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électionnez l'outil de construction pour le projet Java	Sélectionnez Maven.
   Sélectionnez 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 la fonction HTTP générée, car vous ajoutez la Durable Functions à l’étape suivante.

Ajouter des fonctions au projet

1. Dans la palette de commandes, entrez, puis sélectionnez Azure Functions : Créer une fonction.

2. Pour Modifier le filtre de modèle, sélectionnez Tous.

3. 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.

4. 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 pour Durable Functions

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 extensions propriété à votre fichier host.json . Si le fichier possède déjà d’autres propriétés, fusionnez le extensions bloc dans le json existant :

{
  "version": "2.0",
  "extensions": {
    "durableTask": {
      "hubName": "JavaTestHub"
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}