Udostępnij za pośrednictwem

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

Użyj funkcji Durable w ramach Azure Functions do pisania funkcji stanowych w środowisku bezserwerowym. Durable Functions zarządza stanem, punktami kontrolnymi i ponownymi uruchomieniami w aplikacji.

W tym skrótowym przewodniku utworzysz i przetestujesz aplikację Durable Functions hello world w Javie.

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 w Azure, która uruchamia funkcję orkiestratora. W tym przykładzie użyto funkcji wyzwalanej przez protokół HTTP.

Ten krótki przewodnik opisuje różne sposoby na stworzenie aplikacji typu "hello world". Użyj selektora w górnej części strony, aby ustawić preferowane podejście.

Wymagania wstępne

Aby ukończyć tę instrukcję szybkiego startu, potrzebujesz:

  • Zainstalowany pakiet 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 platformy Azure. Aby użyć Durable Functions, musisz mieć konto Azure Storage.

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

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

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.62 -Dtrigger=durablefunctions

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

Podpowiedź Action
groupId Wprowadź com.function.
artifactId Wprowadź 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 .

Konfiguracja dostawcy pamięci zaplecza

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

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

Tworzenie projektu lokalnego

  1. W Visual Studio Code wybierz klawisz F1 (lub naciśnij klawisze Ctrl/Cmd+Shift+P), aby otworzyć paletę poleceń. Po pojawieniu się monitu (>), wybierz 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:

    Podpowiedź Action
    Wybieranie języka Wybierz pozycję Java.
    Wybierz wersję 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ź myDurableFunction.
    Podaj wersję Wprowadź 1.0-SNAPSHOT.
    Podaj nazwę pakietu Wprowadź com.function.
    Podaj nazwę aplikacji Wprowadź myDurableFunction.
    Wybierz narzędzie 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.

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

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

    Podpowiedź Action
    Wybieranie szablonu dla funkcji Wybierz pozycję DurableFunctionsOrchestration.
    Podaj nazwę pakietu Wprowadź com.function.
    Podaj nazwę funkcji Wprowadź 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>

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

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

Lokalne testowanie funkcji

narzędzia Azure Functions Core Tools umożliwiają uruchamianie projektu Azure Functions na lokalnym komputerze programistycznym.

Uwaga / Notatka

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ę trwałą:

    mvn azure-functions:run

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

    Zrzut ekranu lokalnego wyniku 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. Powiadamia Cię, że trwała orkiestracja została pomyślnie uruchomiona. Nie wyświetla jeszcze wyniku końcowego aranżacji. Odpowiedź zawiera kilka przydatnych adresów URL. Na razie zapytaj o stan orkiestracji.

  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.

    Zapytanie kierowane jest do instancji orkiestracji, aby uzyskać status. 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"
}
  • Last updated on