Skapa din första hållbara funktion i Java

Artikel
10/24/2023

Durable Functions är en utökning av Azure Functions som gör att du kan skriva tillståndskänsliga funktioner i en serverlös miljö. Tillägget hanterar tillstånd, kontrollpunkter och omstarter.

I den här snabbstarten får du lära dig hur du skapar och testar en "Hello World" Durable Functions-app i Java. Den mest grundläggande Durable Functions-appen innehåller följande tre funktioner:

Funktionen Orchestrator – beskriver ett arbetsflöde som samordnar andra funktioner.
Aktivitetsfunktion – anropas av orkestreringsfunktionen, utför arbete och returnerar eventuellt ett värde.
Klientfunktion – en vanlig Azure-funktion som startar en orkestreringsfunktion. I det här exemplet används en HTTP-utlöst funktion.

Den här snabbstarten visar hur du skapar den här "Hello World"-appen, vilket du kan göra på olika sätt. Använd väljaren ovan för att välja önskad metod.

Förutsättningar

För att slutföra självstudierna behöver du:

Java Developer Kit, version 8 eller senare.
Apache Maven, version 3.0 eller senare.
Den senaste versionen av Azure Functions Core Tools.
- För Azure Functions 4.x krävs Core Tools v4.0.4915 eller senare.
Ett Azure Storage-konto som kräver att du har en Azure-prenumeration.

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.

Lägga till nödvändiga beroenden och plugin-program i projektet

Lägg till följande i :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>

Lägga till nödvändiga JSON-filer

Lägg till en host.json fil i projektkatalogen. Det bör se ut ungefär så här:

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

Kommentar

Observera att endast Azure Functions v4-tilläggspaketet för närvarande har det stöd som krävs för Durable Functions för Java. Durable Functions för Java stöds inte i v3- och tidiga tilläggspaket. Mer information om tilläggspaket finns i dokumentationen om tilläggspaket.

Durable Functions behöver en lagringsprovider för att lagra körningstillstånd. Lägg till en local.settings.json fil i projektkatalogen för att konfigurera lagringsprovidern. Om du vill använda Azure Storage som provider anger du värdet AzureWebJobsStorage för till anslutningssträng för ditt Azure Storage-konto:

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

Skapa dina funktioner

Exempelkoden nedan visar ett enkelt exempel på varje:

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

Skapa ett lokalt projekt med Maven-kommandot

Kör följande kommando för att generera ett projekt med de grundläggande funktionerna i en Durable Functions-app:

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"

Följ anvisningarna och ange följande information:

Prompt	Värde
Groupid	`com.function`
artifactId	`myDurableFunction`
Version	`1.0-SNAPSHOT`
Paket	`com.function`
Y	Tryck på Retur för att bekräfta

Nu har du ett lokalt projekt som genereras med de tre funktioner som behövs för en grundläggande Durable Functions-app.

Kontrollera att du har com.microsoft:durabletask-azure-functions som beroende i .pom.xml

Konfigurera serverdelslagringsprovider

Durable Functions behöver en lagringsprovider för att lagra körningstillstånd. Du kan konfigurera att använda Azure Storage som lagringsprovider i local.settings.json genom att ange anslutningssträng för ditt Azure Storage-konto som värdet för :AzureWebJobsStorage

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

Skapa ditt lokala projekt

I Visual Studio Code trycker du på F1 (eller Ctrl/Cmd+Skift+P) för att öppna kommandopaletten. I kommandopaletten söker du efter och väljer Azure Functions: Create New Project....
Välj en tom mappplats för projektet och välj Välj.

Följ anvisningarna och ange följande information:

Prompt	Värde
Välj ett språk	Välj `Java`.
Välj en version av Java	Välj `Java 8` eller senare, den Java-version som dina funktioner körs på i Azure. Välj en Java-version som du har verifierat lokalt.
Ange ett grupp-ID	`com.function`.
Ange ett artefakt-ID	`myDurableFunction`.
Ange en version	`1.0-SNAPSHOT`.
Ange ett paketnamn	`com.function`.
Ange ett appnamn	`myDurableFunction`.
Välj byggverktyget för Java-projektet	Välj `Maven`.
Välj hur du vill öppna projektet	Välj `Open in new window`.

Nu har du ett projekt med en http-exempelfunktion. Du kan ta bort den här funktionen om du vill eftersom vi lägger till de grundläggande funktionerna i en Durable Functions-app i nästa steg.

Lägga till funktioner i projektet

I kommandopaletten söker du efter och väljer Azure Functions: Create Function....
Välj Change template filter till All.
Följ anvisningarna och ange följande information:

Prompt Värde

Välj en mall för din funktion DurableFunctionsOrchestration

Ange ett paketnamn com.function

Ange ett funktionsnamn DurableFunctionsOrchestrator
Välj Select storage account i popup-fönstret där du uppmanas att konfigurera lagringskontoinformation och följa anvisningarna.

Prompt	Värde
Välj en mall för din funktion	DurableFunctionsOrchestration
Ange ett paketnamn	`com.function`
Ange ett funktionsnamn	`DurableFunctionsOrchestrator`

Nu bör du ha de tre grundläggande funktionerna för en Durable Functions-app genererad.

Konfigurera pom.xml och host.json

Lägg till följande beroende i :pom.xml

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

Lägg till egenskapen i extensions :host.json

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

Testa funktionen lokalt

Med Azure Functions Core Tools kan du köra ett Azure Functions-projekt på din lokala utvecklingsdator.

Kommentar

Durable Functions för Java kräver Azure Functions Core Tools v4.0.4915 eller senare. Du kan se vilken version som installeras genom att func --version köra kommandot från terminalen.

Om du använder Visual Studio Code öppnar du ett nytt terminalfönster och kör följande kommandon för att skapa projektet:
```
mvn clean package
```
Kör sedan den hållbara funktionen:
```
mvn azure-functions:run
```
På panelen Terminal kopierar du URL-slutpunkten för den HTTP-utlösta funktionen.

Skicka en HTTP POST-begäran till URL-slutpunkten med hjälp av ett verktyg som Postman eller cURL. Du bör få ett svar som liknar följande:

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

Svaret är det första resultatet från HTTP-funktionen som låter dig veta att den varaktiga orkestreringen har startats. Det är inte ännu slutresultatet av orkestreringen. Svaret innehåller några användbara URL:er. För tillfället kör vi en fråga om orkestreringens status.

Kopiera URL-värdet för statusQueryGetUri och klistra in det i webbläsarens adressfält och kör begäran. Du kan också fortsätta att använda Postman eller cURL för att utfärda GET-begäran.

Begäran kör en fråga mot orkestreringsinstansen om statusen. Du bör få ett slutligt svar som visar att instansen har slutförts och innehåller utdata eller resultat från den varaktiga funktionen. Det ser ut så här:
```
{
    "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"
}
```

Dela via