Avvio rapido: Creare un'app Java Durable Functions

Aggiungere le dipendenze e i plug-in necessari al progetto

Aggiungere il codice seguente al file 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>

Aggiungere i file JSON necessari

Aggiungere un file host.json alla directory del progetto. Dovrebbe risultare simile all'esempio seguente:

{
  "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 richiede un provider di archiviazione per archiviare lo stato di runtime. Aggiungere un file local.settings.json alla directory del progetto per configurare il provider di archiviazione. Per usare Archiviazione di Azure come provider, impostare il valore di AzureWebJobsStorage sulla stringa di connessione dell'account di Archiviazione di Azure:

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

Creare le funzioni

Il codice di esempio seguente illustra un esempio di base di ogni tipo di funzione:

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();
    }
}

Creare un progetto locale usando il comando Maven

Eseguire il comando seguente per generare un progetto contenente le funzioni di base di un'app 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"

Quando richiesto, immettere le informazioni seguenti:

È ora disponibile un progetto locale con le tre funzioni incluse in un'app Durable Functions di base.

Verificare che com.microsoft:durabletask-azure-functions sia impostato come dipendenza nel file pom.xml.

Configurare il provider di archiviazione back-end

Durable Functions richiede un provider di archiviazione per archiviare lo stato di runtime. È possibile impostare Archiviazione di Azure come provider di archiviazione in local.settings.json. Usare la stringa di connessione dell'account di archiviazione di Azure come valore per AzureWebJobsStorage come nell'esempio seguente:

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

Creare il progetto locale

1. In Visual Studio Code, selezionare F1 (o Ctrl/Cmd+Maiuscolo+P) per aprire il riquadro comandi. Quando richieste (>), immettere e selezionare Funzioni di Azure: Crea nuovo progetto.

   

2. Selezionare Sfoglia. Nella finestra di dialogo Seleziona cartella andare a una cartella da usare per il progetto, quindi scegliere Seleziona.

3. Quando richiesto, immettere le informazioni seguenti:

   Richiesta	Azione
   Selezionare una lingua	Selezionare Java.
   Selezionare una versione di Java	Selezionare Java 8 o versione successiva. Selezionare la versione Java in cui vengono eseguite le funzioni in Azure e una verificata in locale.
   Specificare un ID gruppo	Immettere com.function.
   Specificare un ID artefatto	Immettere myDurableFunction.
   Specificare una versione	Immettere 1.0-SNAPSHOT.
   Specificare un nome di pacchetto	Immettere com.function.
   Specificare un nome di app	Immettere myDurableFunction.
   Selezionare lo strumento di compilazione per il progetto Java	Selezionare Maven.
   Selezionare come si vuole aprire il progetto	Selezionare Apri in nuova finestra.

È ora disponibile un progetto con una funzione HTTP di esempio. È possibile rimuovere questa funzione se si desidera, perché si aggiungono le funzioni di base di un'app Durable Functions nel passaggio successivo.

Aggiungere funzioni al progetto

1. Nel riquadro comandi immettere e selezionare Funzioni di Azure: Crea funzione.

2. Per Modifica filtro modello, selezionare Tutti.

3. Quando richiesto, immettere le informazioni seguenti:

   Richiesta	Azione
   Selezionare un modello per la funzione	Selezionare DurableFunctionsOrchestration.
   Specificare un nome di pacchetto	Immettere com.function.
   Specificare un nome di funzione	Immettere DurableFunctionsOrchestrator.

4. Nella finestra di dialogo scegliere Selezionare l'account di archiviazione per configurare un account di archiviazione quindi seguire le istruzioni.

Ora dovrebbero essere presenti le tre funzioni di base generate per un'app Durable Functions.

Configurare pom.xml e host.json

Aggiungere la dipendenza seguente al file pom.xml:

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

Aggiungere la proprietà extensions al file host.json:

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