Udostępnij za pośrednictwem

Szybki start: tworzenie aplikacji Durable Functions w języku Java

  • Artykuł

Użyj rozszerzenia Durable Functions, funkcji usługi Azure Functions, aby napisać funkcje stanowe w środowisku bezserwerowym. Rozszerzenie Durable Functions zarządza stanem, punktami kontrolnymi i ponownymi uruchomieniami w aplikacji.

W tym przewodniku Szybki start utworzysz i przetestujesz aplikację Durable Functions "hello world" w języku Java.

Najbardziej podstawowa aplikacja Durable Functions ma trzy funkcje:

  • Funkcja orkiestratora: przepływ pracy, który organizuje inne funkcje.
  • Funkcja działania: funkcja wywoływana przez funkcję orkiestratora, wykonuje pracę i opcjonalnie zwraca wartość.
  • Funkcja klienta: zwykła funkcja na platformie Azure, która uruchamia funkcję orkiestratora. W tym przykładzie użyto funkcji wyzwalanej przez protokół HTTP.

W tym przewodniku Szybki start opisano różne sposoby tworzenia tej aplikacji "hello world". Użyj selektora w górnej części strony, aby ustawić preferowane podejście.

Wymagania wstępne

Aby ukończyć ten przewodnik Szybki Start, musisz spełnić następujące warunki:

  • Zainstalowany zestaw Java Developer Kit w wersji 8 lub nowszej.

  • Zainstalowano oprogramowanie Apache Maven w wersji 3.0 lub nowszej.

  • Najnowsza wersja narzędzi Azure Functions Core Tools.

    W przypadku usługi Azure Functions 4.x wymagane są narzędzia Core Tools w wersji 4.0.4915 lub nowszej.

  • Narzędzie do testowania HTTP, które zapewnia bezpieczeństwo danych. Aby uzyskać więcej informacji, zobacz Narzędzia do testowania HTTP.

  • Subskrypcja Azure. Aby korzystać z rozszerzenia Durable Functions, musisz mieć konto usługi Azure Storage.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.

Dodawanie wymaganych zależności i wtyczek do projektu

Dodaj następujący kod do pliku 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>

Dodawanie wymaganych plików JSON

Dodaj plik host.json do katalogu projektu. Powinien on wyglądać podobnie do poniższego przykładu:

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

Uwaga

Należy pamiętać, że obecnie tylko pakiet rozszerzeń usługi Azure Functions w wersji 4 ma wymaganą obsługę rozszerzenia Durable Functions dla języka Java. Rozszerzenie Durable Functions dla języka Java nie jest obsługiwane w pakietach rozszerzeń w wersji 3 i wczesnych wersjach. Aby uzyskać więcej informacji na temat pakietów rozszerzeń, zobacz dokumentację pakietów rozszerzeń.

Rozszerzenie Durable Functions wymaga dostawcy magazynu do przechowywania stanu środowiska uruchomieniowego. Dodaj plik local.settings.json do katalogu projektu, aby skonfigurować dostawcę magazynu. Aby użyć usługi Azure Storage jako dostawcy, ustaw wartość AzureWebJobsStorage na parametry połączenia konta usługi Azure Storage:

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

Tworzenie funkcji

Poniższy przykładowy kod przedstawia podstawowy przykład poszczególnych typów funkcji:

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

Tworzenie projektu lokalnego przy użyciu polecenia Maven

Uruchom następujące polecenie, aby wygenerować projekt zawierający podstawowe funkcje aplikacji Durable Functions:

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

Po wyświetleniu monitów podaj następujące informacje:

Monit Akcja
groupId Wprowadź com.function.
artifactId Wprowadź wartość myDurableFunction.
version Wybierz pozycję 1.0-SNAPSHOT.
pakiet Wprowadź com.function.
Y Wprowadź wartość Y i wybierz Enter, aby potwierdzić.

Teraz masz projekt lokalny z trzema funkcjami, które znajdują się w podstawowej aplikacji Durable Functions.

Upewnij się, że com.microsoft:durabletask-azure-functions jest ustawiona jako zależność w pliku pom.xml .

Konfigurowanie dostawcy magazynu zaplecza

Rozszerzenie Durable Functions wymaga dostawcy magazynu do przechowywania stanu środowiska uruchomieniowego. Usługę Azure Storage można ustawić jako dostawcę magazynu w local.settings.json. Użyj parametry połączenia konta usługi Azure Storage jako wartości podobnej AzureWebJobsStorage w tym przykładzie:

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

Tworzenie projektu lokalnego

  1. W programie Visual Studio Code wybierz F1 (lub naciśnij Ctrl/Cmd+Shift+P), aby otworzyć paletę poleceń. Po wyświetleniu monitu () wprowadź , a następnie wybierz pozycję Azure Functions: Create New Project (>Azure Functions: Utwórz nowy projekt).

    Zrzut ekranu przedstawiający polecenie tworzenia nowego projektu funkcji.

  2. Wybierz przycisk Przeglądaj. W oknie dialogowym Wybieranie folderu przejdź do folderu, który ma być używany dla projektu, a następnie wybierz pozycję Wybierz.

  3. Po wyświetleniu monitów podaj następujące informacje:

    Monit Akcja
    Wybieranie języka Wybierz pozycję Java.
    Wybieranie wersji języka Java Wybierz pozycję Java 8 lub nowszą. Wybierz wersję języka Java, na której działają funkcje na platformie Azure, i wersję zweryfikowaną lokalnie.
    Podaj identyfikator grupy Wprowadź com.function.
    Podaj identyfikator artefaktu Wprowadź wartość myDurableFunction.
    Podaj wersję Wprowadź wartość 1.0-SNAPSHOT.
    Podaj nazwę pakietu Wprowadź com.function.
    Podaj nazwę aplikacji Wprowadź wartość myDurableFunction.
    Wybieranie narzędzia kompilacji dla projektu Java Wybierz pozycję Maven.
    Wybierz sposób otwierania projektu Wybierz pozycję Otwórz w nowym oknie.

Masz teraz projekt, który ma przykładową funkcję HTTP. Możesz usunąć tę funkcję, jeśli chcesz, ponieważ w następnym kroku dodasz podstawowe funkcje aplikacji Durable Functions.

Dodawanie funkcji do projektu

  1. W palecie poleceń wprowadź , a następnie wybierz pozycję Azure Functions: Create Function (Azure Functions: Utwórz funkcję).

  2. W obszarze Zmień filtr szablonu wybierz pozycję Wszystkie.

  3. Po wyświetleniu monitów podaj następujące informacje:

    Monit Akcja
    Wybieranie szablonu dla funkcji Wybierz pozycję DurableFunctionsOrchestration.
    Podaj nazwę pakietu Wprowadź com.function.
    Podaj nazwę funkcji Wprowadź ciąg DurableFunctionsOrchestrator.

  4. W oknie dialogowym wybierz pozycję Wybierz konto magazynu, aby skonfigurować konto magazynu, a następnie postępuj zgodnie z monitami.

Teraz powinny istnieć trzy podstawowe funkcje wygenerowane dla aplikacji Durable Functions.

Konfigurowanie pom.xml i host.json

Dodaj następującą zależność do pliku pom.xml :

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

extensions Dodaj właściwość do pliku host.json:

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

Lokalne testowanie funkcji

Narzędzia Azure Functions Core Tools umożliwiają uruchamianie projektu usługi Azure Functions na lokalnym komputerze deweloperów.

Uwaga

Rozszerzenie Durable Functions dla języka Java wymaga narzędzi Azure Functions Core Tools w wersji 4.0.4915 lub nowszej. Wersję zainstalowaną można sprawdzić, uruchamiając func --version polecenie w terminalu.

  1. Jeśli używasz programu Visual Studio Code, otwórz nowe okno terminalu i uruchom następujące polecenia, aby skompilować projekt:

    mvn clean package

    Następnie uruchom funkcję durable:

    mvn azure-functions:run

  2. Na panelu terminalu skopiuj punkt końcowy adresu URL funkcji wyzwalanej przez protokół HTTP.

    Zrzut ekranu przedstawiający lokalne dane wyjściowe platformy Azure.

  3. Użyj narzędzia testowego HTTP, aby wysłać żądanie HTTP POST do punktu końcowego adresu URL.

    Odpowiedź powinna wyglądać podobnie do poniższego przykładu:

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

    Odpowiedź to początkowy wynik funkcji HTTP. Informuje o tym, że trwała aranżacja została pomyślnie uruchomiona. Nie wyświetla jeszcze wyniku końcowego aranżacji. Odpowiedź zawiera kilka przydatnych adresów URL. Na razie wykonaj zapytanie dotyczące stanu aranżacji.

  4. Skopiuj wartość adresu URL dla statusQueryGetUri, wklej ją na pasku adresu przeglądarki i wykonaj żądanie. Alternatywnie możesz nadal używać narzędzia do testowania HTTP w celu wystawienia żądania GET.

    Żądanie wysyła zapytanie do wystąpienia orkiestracji dla stanu. Powinno zostać wyświetlone, że wystąpienie zostało zakończone i że zawiera dane wyjściowe lub wyniki funkcji trwałej, tak jak w tym przykładzie:

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