Partilhar via

Guia de início rápido: criar um aplicativo Java Durable Functions

  • Artigo

Use Durable Functions, um recurso do Azure Functions, para escrever funções com monitoração de estado em um ambiente sem servidor. O Durable Functions gerencia o estado, os pontos de verificação e as reinicializações em seu aplicativo.

Neste início rápido, você cria e testa um aplicativo de Funções Duráveis "hello world" em Java.

O aplicativo Durable Functions mais básico tem três funções:

  • Função Orchestrator: um fluxo de trabalho que orquestra outras funções.
  • Função de atividade: uma função que é chamada pela função orquestradora, executa trabalho e, opcionalmente, retorna um valor.
  • Função de cliente: uma função regular no Azure que inicia uma função de orquestrador. Este exemplo usa uma função acionada por HTTP.

Este guia de início rápido descreve diferentes maneiras de criar este aplicativo "hello world". Use o seletor na parte superior da página para definir sua abordagem preferida.

Pré-requisitos

Para concluir este guia de início rápido, necessita de:

  • O Java Developer Kit versão 8 ou posterior instalado.

  • Apache Maven versão 3.0 ou posterior instalado.

  • A versão mais recente das Ferramentas Principais do Azure Functions.

    Para o Azure Functions 4.x, é necessário o Core Tools versão 4.0.4915 ou posterior.

  • Uma ferramenta de teste HTTP que mantém seus dados seguros. Para obter mais informações, consulte Ferramentas de teste HTTP.

  • Uma subscrição do Azure. Para usar o Durable Functions, você deve ter uma conta de Armazenamento do Azure.

Se não tiver uma subscrição do Azure, crie uma conta gratuita do Azure antes de começar.

Adicione dependências e plug-ins necessários ao seu projeto

Adicione o seguinte código ao seu arquivo 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>

Adicione os arquivos JSON necessários

Adicione um arquivo host.json ao diretório do projeto. Deve ser semelhante ao 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)"
  }
}

Nota

É importante observar que apenas o pacote de extensão do Azure Functions v4 atualmente tem o suporte necessário para Durable Functions for Java. O Durable Functions for Java não é suportado na v3 e nos pacotes de extensão anteriores. Para obter mais informações sobre pacotes de extensão, consulte a documentação de pacotes de extensão.

O Durable Functions precisa de um provedor de armazenamento para armazenar o estado de tempo de execução. 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 para a cadeia de conexão da sua conta de AzureWebJobsStorage Armazenamento do Azure:

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

Crie as suas funções

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 local usando o comando Maven

Execute o seguinte comando para gerar um projeto que contém as funções básicas de um aplicativo Durable Functions:

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

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

Pedido Ação
groupId Digite com.function.
artifactId Digite myDurableFunction.
Versão Selecione 1.0-SNAPSHOT.
embalagem Digite com.function.
Y Digite Y e selecione Enter para confirmar.

Agora você tem um projeto local que tem as três funções que estão em um aplicativo básico de Funções Duráveis.

Verifique se com.microsoft:durabletask-azure-functions isso está definido como uma dependência em seu arquivo pom.xml .

Configurar o provedor de armazenamento back-end

O Durable Functions precisa de um provedor de armazenamento para armazenar o estado de tempo de execução. Você pode definir o Armazenamento do Azure como o provedor de armazenamento no local.settings.json. Use a cadeia de conexão da sua conta de armazenamento do Azure como o valor para AzureWebJobsStorage like neste exemplo:

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

Criar o seu projeto local

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

    Captura de tela do comando create new functions project (criar novas funções).

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

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

    Pedido Ação
    Selecione um idioma Selecione Java.
    Selecione uma versão do Java Selecione Java 8 ou posterior. Selecione a versão do Java em que suas funções são executadas no Azure e uma que você verificou localmente.
    Fornecer um ID de grupo Digite com.function.
    Fornecer um ID de artefato Digite myDurableFunction.
    Fornecer uma versão Digite 1.0-SNAPSHOT.
    Forneça um nome de pacote Digite com.function.
    Fornecer um nome de aplicativo Digite myDurableFunction.
    Selecione a ferramenta de construção para o projeto Java Selecione Maven.
    Selecione como gostaria de abrir o seu projeto Selecione Abrir em nova janela.

Agora você tem um projeto que tem uma função HTTP de exemplo. Você pode remover essa função se desejar, porque você adiciona as funções básicas de um aplicativo Durable Functions na próxima etapa.

Adicionar funções ao projeto

  1. Na paleta de comandos, insira e selecione Azure Functions: Create Function.

  2. Em Alterar filtro de modelo, selecione Todos.

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

    Pedido Ação
    Selecione um modelo para a sua função Selecione DurableFunctionsOrchestration.
    Forneça um nome de pacote Digite com.function.
    Fornecer um nome de função Digite DurableFunctionsOrchestrator.

  4. Na caixa de diálogo, escolha Selecionar conta de armazenamento para configurar uma conta de armazenamento e siga as instruções.

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

Configurar pom.xml e host.json

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

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

Adicione a extensions propriedade ao seu arquivo de host.json :

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

Testar localmente a função

As Ferramentas Principais do Azure Functions oferecem a capacidade de executar um projeto do Azure Functions em seu computador de desenvolvimento local.

Nota

O Durable Functions for Java requer o Azure Functions Core Tools versão 4.0.4915 ou posterior. Você pode ver qual versão está instalada executando o func --version comando no terminal.

  1. Se você estiver usando o Visual Studio Code, abra uma nova janela do terminal e execute os seguintes comandos para criar o projeto:

    mvn clean package

    Em seguida, execute a função durável:

    mvn azure-functions:run

  2. No painel do terminal, copie o ponto de extremidade URL da sua função acionada por HTTP.

    Captura de ecrã da saída local do Azure.

  3. Use uma ferramenta de teste HTTP para enviar uma solicitação HTTP POST para o ponto de extremidade URL.

    A resposta deve ser semelhante ao exemplo a seguir:

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

    A resposta é o resultado inicial da função HTTP. Ele permite que você saiba que a orquestração durável começou com sucesso. Ainda não exibe o resultado final da orquestração. A resposta inclui alguns URLs úteis. Por enquanto, consulte o status da orquestração.

  4. Copie o valor do URL para statusQueryGetUri, cole-o na barra de endereço do navegador e execute a solicitação. Como alternativa, você pode continuar a usar a ferramenta de teste HTTP para emitir a solicitação GET.

    A solicitação consulta a instância de orquestração para obter o status. Você deve ver que a instância terminou e que inclui as saídas ou resultados da função durável, como neste exemplo:

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