Snabbstart: Skapa en Java Durable Functions-app

Använd Durable Functions, en funktion i Azure Functions, för att skriva tillståndskänsliga funktioner i en serverlös miljö. Durable Functions hanterar tillstånd, kontrollpunkter och omstarter i ditt program.

I den här snabbstarten skapar och testar du en Durable Functions-app i Java.

En grundläggande Durable Functions app har tre funktioner:

  • Orchestrator-funktion (Cities): Ett arbetsflöde som samordnar andra funktioner.
  • Aktivitetsfunktion (Capitalize): En funktion som orkestratorn anropar för att utföra arbete och returnera ett värde.
  • Klientfunktion (StartOrchestration): En HTTP-utlöst funktion som startar orkestratorn.

Den här snabbstarten erbjuder tre installationsalternativ. Använd väljaren överst på sidan för att välja önskad metod:

  • Manuell installation: Skapa varje fil för hand för fullständig kontroll över projektstrukturen.
  • Maven-kommando: Använd en Maven-arketyp för att strukturera projektet med ett enda kommando.
  • Visual Studio Code: Använd TILLÄGGET VS Code Azure Functions för att generera projektet via ett guidat användargränssnitt.

Förutsättningar

Följande krävs för att slutföra den här snabbstarten:

  • Java Developer Kit version 8 eller senare installerat.

  • Apache Maven version 3.0 eller senare installerat.

  • Den senaste versionen av Azure Functions Core Tools.

    För Azure Functions 4.x krävs Core Tools version 4.0.4915 eller senare.

  • Ett HTTP-testverktyg som skyddar dina data. Mer information finns i HTTP-testverktyg.

  • Visual Studio Code med tillägget Azure Functions installerat (krävs endast för installationssökvägen Visual Studio Code).

  • Ett Azure-abonnemang. Om du vill använda Durable Functions måste du ha ett Azure Storage konto.

Om du inte har något Azure-konto skapar du ett kostnadsfritt konto innan du börjar.

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

Lägg till följande kod i filenpom.xml . Innan du kopierar det ersätter your-unique-app-name du med ett globalt unikt funktionsappnamn. Justera region, javaVersionoch resourceGroup för att matcha din miljö.

<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ägg till nödvändiga JSON-filer

Lägg till en host.json fil i projektkatalogen. Det bör se ut ungefär som i följande exempel:

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

Anmärkning

Durable Functions för Java kräver tilläggspaket v4. Tidigare paket stöds inte. Mer information finns i dokumentationen om tilläggspaket.

Durable Functions behöver en lagringsleverantör för att lagra körningstillståndet. 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"
  }
}

Viktigt!

Filen local.settings.json kan innehålla hemligheter. Se till att du lägger till den i .gitignore-filen för att undvika att checka in den i källkontrollen.

Skapa Durable Functions-orkestrerings-, aktivitets- och klientfunktioner

Följande exempelkod visar ett grundläggande exempel på varje typ av funktion:

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

Skapa ett lokalt Durable Functions projekt med hjälp av Maven-kommandot

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

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

Ange följande information vid anvisningarna:

Omedelbar Action
groupId Ange com.function.
artifactId Ange myDurableFunction.
version Välj 1.0-SNAPSHOT.
paket Ange com.function.
Y Ange Y och välj Retur för att bekräfta.

Nu har du ett lokalt projekt som har de tre funktionerna som finns i en grundläggande Durable Functions-app. Arketypen innehåller com.microsoft:durabletask-azure-functions automatiskt som ett beroende i dinpom.xml fil.

Konfigurera leverantören för serverdelslagring för Durable Functions

Durable Functions behöver en lagringsleverantör för att lagra körningstillståndet. Du kan ange Azure Storage som lagringsprovider i local.settings.json. Använd anslutningssträng för ditt Azure Storage-konto som värde för AzureWebJobsStorage som i det här exemplet:

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

Viktigt!

Filen local.settings.json kan innehålla hemligheter. Se till att du lägger till den i .gitignore-filen för att undvika att checka in den i källkontrollen.

Skapa ditt lokala projekt

  1. I Visual Studio Code väljer du F1 (eller ctrl/cmd+Skift+P) för att öppna kommandopaletten. I kommandotolken (>) anger du och väljer sedan Azure Functions: Skapa nytt projekt.

    Screenshot av kommandot Azure Functions Create New Project i kommandopaletten Visual Studio Code.

  2. Välj Bläddra. I dialogrutan Välj mapp går du till en mapp som ska användas för projektet och väljer sedan Välj.

  3. Ange följande information vid anvisningarna:

    Omedelbar Action
    Välj ett språk Välj Java.
    Välj en version av Java Välj Java 8 eller senare. Välj den Java-version som funktionerna körs på i Azure och en som du har verifierat lokalt.
    Ange ett grupp-ID Ange com.function.
    Ange ett artefakt-ID Ange myDurableFunction.
    Tillhandahåll en version Ange 1.0-SNAPSHOT.
    Ange ett paketnamn Ange com.function.
    Ange ett appnamn Ange myDurableFunction.
    Välj byggverktyget för Java projekt Välj Maven.
    Välj hur du vill öppna projektet Välj Öppna i nytt fönster.

Nu har du ett projekt som har en HTTP-exempelfunktion. Du kan ta bort den genererade HTTP-funktionen eftersom du lägger till Durable Functions i nästa steg.

Lägga till funktioner i projektet

  1. I kommandopaletten anger du och väljer sedan Azure Functions: Skapa funktion.

  2. För Ändra mallfilter väljer du Alla.

  3. Ange följande information vid anvisningarna:

    Omedelbar Action
    Välj en mall för din funktion Välj DurableFunctionsOrchestration.
    Ange ett paketnamn Ange com.function.
    Ange ett funktionsnamn Ange DurableFunctionsOrchestrator.

  4. I dialogrutan väljer du Välj lagringskonto för att konfigurera ett lagringskonto och följer sedan anvisningarna.

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

Konfigurera pom.xml och host.json för Durable Functions

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

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

Lägg till extensions-egenskapen i din host.json-fil. Om filen redan har andra egenskaper sammanfogar du extensions blocket till den befintliga JSON:en:

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

Testa funktionen lokalt

Azure Functions Core Tools ger dig möjlighet att köra ett Azure Functions projekt på din lokala utvecklingsdator.

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

  2. I terminalpanelen kopierar du URL-slutpunkten för din HTTP-utlösta funktion.

    Skärmbild av terminalutdata som visar HTTP-slutpunkts-URL:en för den lokala Azure Functions runtime.

  3. Använd HTTP-testverktyget för att skicka en HTTP POST-begäran till URL-slutpunkten.

    Svaret bör se ut ungefär som i följande exempel:

    {
    "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 HTTP-funktionens första resultat. Den informerar dig om att den hållbara orkestreringen har startats framgångsrikt. Det visar ännu inte slutresultatet av orkestreringen. Svaret innehåller några användbara URL:er. För tillfället, kontrollera status för orkestreringen.

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

    Begäran frågar orkestreringsinstansen om statusen. Du bör se att instansen har slutförts och att den innehåller utdata eller resultat från den varaktiga funktionen, som i det här exemplet:

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