Início Rápido: criar um aplicativo Java de Durable Functions

Adicionar as dependências e os plug-ins necessários ao projeto

Adicione o código a seguir ao arquivo pom.xml . Antes de copiá-lo, substitua your-unique-app-name por um nome de aplicativo de funções globalmente exclusivo. Ajuste region, javaVersion e resourceGroup para corresponder ao seu ambiente.

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

Adicionar os arquivos JSON necessários

Adicione um arquivo host.json ao seu diretório de projeto. Ela deve ser parecida com o seguinte exemplo:

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

As Durable Functions precisam ter um provedor de armazenamento para armazenar o estado de runtime. Adicione um arquivo local.settings.json ao diretório do projeto para configurar o provedor de armazenamento. Para usar o Armazenamento do Azure como provedor, defina o valor de AzureWebJobsStorage como a cadeia de conexão da sua conta do Armazenamento do Azure:

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

Criar seu orquestrador Durable Functions, atividade e funções de cliente

O código de exemplo a seguir mostra um exemplo básico de cada tipo de função:

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

Criar um projeto de Durable Functions local usando o comando Maven

Execute o seguinte comando para gerar um projeto que contém as funções básicas de um aplicativo de 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"

Nos prompts, forneça as informações a seguir:

Agora você tem um projeto local que tem as três funções que estão em um aplicativo de Durable Functions básico. O arquétipo inclui com.microsoft:durabletask-azure-functions como uma dependência em seu arquivo pom.xml automaticamente.

Configurar o provedor de armazenamento de back-end para Durable Functions

As Durable Functions precisam ter um provedor de armazenamento para armazenar o estado de runtime. Você pode definir o Armazenamento do Microsoft Azure como o provedor de armazenamento em local.settings.json. Use a cadeia de conexão da sua conta de armazenamento do Azure como o valor para AzureWebJobsStorage como neste exemplo:

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

Criar seu projeto local

1. Em Visual Studio Code, selecione F1 (ou selecione Ctrl/Cmd+Shift+P) para abrir a paleta de comandos. No prompt (>), insira e selecione Azure Functions: Criar Novo Projeto.

   

2. Selecione Procurar. Na caixa de diálogo Selecionar Pasta, vá para uma pasta a ser usada em seu projeto e escolha Selecionar.

3. Nos prompts, forneça as informações a seguir:

   Rápido	Ação
   Selecione um idioma	Selecione Java.
   Selecione uma versão do Java	Selecione Java 8 ou posterior. Selecione a versão do Java na qual suas funções são executadas no Azure e uma que você verificou localmente.
   Forneça uma ID de grupo	Insira com.function.
   Forneça uma ID de artefato	Insira myDurableFunction.
   Forneça uma versão	Insira 1.0-SNAPSHOT.
   Forneça um nome de pacote	Insira com.function.
   Forneça um nome de aplicativo	Insira myDurableFunction.
   Selecione a ferramenta de build para projeto Java	Selecione Maven.
   Selecione como deseja abrir o projeto	Selecione Abrir em nova janela.

Agora você tem um projeto que tem uma função HTTP de exemplo. Você pode remover a função HTTP gerada porque adiciona o Durable Functions na próxima etapa.

Adicionar funções ao projeto

1. Na paleta de comandos, insira e selecione Azure Functions: Criar Função.

2. Em Alterar filtro de modelo, selecione Todos.

3. Nos prompts, forneça as informações a seguir:

   Rápido	Ação
   Selecione um modelo para sua função	Selecione DurableFunctionsOrchestration.
   Forneça um nome de pacote	Insira com.function.
   Forneça um nome para a função	Insira DurableFunctionsOrchestrator.

4. Na caixa de diálogo, escolha Selecionar conta de armazenamento para configurar uma conta de armazenamento e, em seguida, siga os prompts.

Agora você tem as três funções básicas geradas para um aplicativo de Durable Functions.

Configurar pom.xml e host.json para Durable Functions

Adicione a seguinte dependência ao arquivo pom.xml:

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

Adicione a extensions propriedade ao arquivo host.json . Se o arquivo já tiver outras propriedades, mescle o extensions bloco no JSON existente:

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