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

Użyj Durable Functions, funkcji platformy Azure Functions, aby tworzyć stanowe przepływy pracy w modelu bezserwerowym w języku Java. W tym przewodniku Szybki start sklonujesz i uruchomisz przykładową aplikację, która demonstruje dwa typowe wzorce aranżacji:

  • Łańcuch funkcji: sekwencyjnie wywołuje działania (Tokio → Seattle → Londynie).
  • Fan-out/fan-in: Wywołuje działania równolegle w pięciu miastach, a następnie agreguje wyniki.

Na koniec obie orkiestracje będą uruchomione lokalnie z emulatorem Durable Task Scheduler, a ich stan będzie można wyświetlić w pulpicie nawigacyjnym.

  • Sklonuj i przygotuj przykładowy projekt Hello Cities.
  • Skonfiguruj emulator narzędzia Durable Task Scheduler i Azurite na potrzeby programowania lokalnego.
  • Zbuduj i uruchom aplikację funkcji oraz wyzwól obie orkiestracje.
  • Przejrzyj stan orkiestracji i dane wyjściowe na pulpicie nawigacyjnym narzędzia Durable Task Scheduler.

Wymagania wstępne

Konfigurowanie emulatora harmonogramu zadań Durable Task Scheduler

Emulator harmonogramu zadań Durable udostępnia lokalne środowisko programistyczne, dzięki czemu można testować aranżacje bez subskrypcji Azure. Host usługi Java Functions wymaga również Azurite dla magazynu lokalnego.

Uruchom oba kontenery:

docker run -d --name dtsemulator -p 8080:8080 -p 8082:8082 \
  mcr.microsoft.com/dts/dts-emulator:latest

docker run -d --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 \
  mcr.microsoft.com/azure-storage/azurite

Wskazówka

Po uruchomieniu emulatora możesz uzyskać dostęp do pulpitu nawigacyjnego narzędzia Durable Task Scheduler pod adresem , http://localhost:8082 aby monitorować aranżacje.

Uruchom przykład szybkiego startu

  1. Przejdź do przykładowego katalogu Hello Cities:

    cd samples/durable-functions/java/HelloCities

  2. Sprawdź, czy local.settings.json plik zawiera następującą konfigurację:

    {
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "java",
    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
  }
}

  3. Skompiluj projekt:

    mvn clean package

  4. Uruchom aplikację funkcji:

    mvn azure-functions:run

  5. W osobnym terminalu wyzwól orkiestrację łańcucha funkcji :

    $response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartChaining
$response

    Odpowiedź zawiera adresy URL stanu wystąpienia orkiestracji. statusQueryGetUri Skopiuj wartość i uruchom ją, aby sprawdzić wynik:

    Invoke-RestMethod -Uri $response.statusQueryGetUri

  6. Uruchom orkiestrację fan-out/fan-in:

    $response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartFanOutFanIn
Invoke-RestMethod -Uri $response.statusQueryGetUri

Oczekiwane dane wyjściowe

Żądanie POST zwraca odpowiedź w formacie JSON z adresami URL statusu. Przykład:

{
  "id": "<instanceId>",
  "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/<instanceId>?code=...",
  "sendEventPostUri": "...",
  "terminatePostUri": "...",
  "purgeHistoryDeleteUri": "..."
}

Gdy wykonasz zapytanie do statusQueryGetUri i gdy element runtimeStatus orkiestracji ma wartość Completed, wyniki powitania znajdziesz w polu output. Orkiestracja łańcuchowa zwraca:

{
  "name": "ChainingOrchestration",
  "runtimeStatus": "Completed",
  "output": "Hello Tokyo! Hello Seattle! Hello London!"
}

Orkiestracja typu fan-out/fan-in zwraca:

{
  "name": "FanOutFanInOrchestration",
  "runtimeStatus": "Completed",
  "output": ["Hello Tokyo!", "Hello Seattle!", "Hello London!", "Hello Paris!", "Hello Berlin!"]
}

Wskazówka

Jeśli runtimeStatus pokazuje Running lub Pending, zaczekaj chwilę i ponownie wykonaj zapytanie do statusQueryGetUri.

Otwórz pulpit narzędzia Durable Task Scheduler pod adresem http://localhost:8082, aby wyświetlić stan orkiestracji i historię wykonywania.

Omówienie kodu

Przykładowy projekt w src/main/java/com/example/Functions.java zawiera wszystkie trzy typy funkcji potrzebne dla aplikacji Durable Functions.

Funkcja aktywności

Działanie SayHello przyjmuje nazwę miasta i zwraca powitanie:

@FunctionName("SayHello")
public String sayHello(
        @DurableActivityTrigger(name = "city") String city) {
    return "Hello " + city + "!";
}

Funkcje programu Orchestrator

Orkiestrator łańcuchowy wywołuje SayHello sekwencyjnie dla trzech miast:

@FunctionName("ChainingOrchestration")
public String chainingOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {

    String result = "";
    result += ctx.callActivity("SayHello", "Tokyo", String.class).await();
    result += " " + ctx.callActivity("SayHello", "Seattle", String.class).await();
    result += " " + ctx.callActivity("SayHello", "London", String.class).await();
    return result;
}

Orkiestrator fan-out/fan-in harmonogramuje aktywności równolegle:

@FunctionName("FanOutFanInOrchestration")
public List<String> fanOutFanInOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {

    String[] cities = {"Tokyo", "Seattle", "London", "Paris", "Berlin"};
    List<Task<String>> parallelTasks = new ArrayList<>();

    for (String city : cities) {
        parallelTasks.add(ctx.callActivity("SayHello", city, String.class));
    }

    List<String> results = new ArrayList<>();
    for (Task<String> task : parallelTasks) {
        results.add(task.await());
    }

    return results;
}

Funkcje klienta

Funkcje klienta wyzwalane przez protokół HTTP uruchamiają każdą aranżację:

@FunctionName("StartChaining")
public HttpResponseMessage startChaining(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<Void> request,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {

    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance("ChainingOrchestration");
    return durableContext.createCheckStatusResponse(request, instanceId);
}

Konfiguracja

W przykładzie jako zaplecze magazynu danych użyto emulatora Durable Task Scheduler. Jest to skonfigurowane w programie host.json:

{
  "extensions": {
    "durableTask": {
      "hubName": "default",
      "storageProvider": {
        "type": "azureManaged",
        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
      }
    }
  }
}

Parametr połączenia emulatora jest ustawiony w local.settings.json:

{
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "java",
    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
  }
}

Uprzątnij zasoby

Zatrzymaj kontenery emulatora, gdy skończysz:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Następne kroki

  • Last updated on