Quickstart: Een Java Durable Functions-app maken

Gebruik Durable Functions, een functie van Azure Functions, om stateful serverloze werkstromen te schrijven in Java. In deze snelstartgids kloont u een voorbeeldtoepassing en voert u deze uit, waarin twee veelvoorkomende orkestratiepatronen worden gedemonstreerd:

  • Functiekoppeling: Roept activiteiten opeenvolgend aan (Tokio → Seattle → Londen).
  • Fan-out/fan-in: roept activiteiten parallel aan in vijf steden en voegt vervolgens de resultaten samen.

Aan het einde hebt u beide orchestraties lokaal draaien met de Durable Task Scheduler-emulator en kunt u hun status bekijken in het dashboard.

  • Kloon en bereid het Hello Cities-voorbeeldproject voor.
  • Stel de Durable Task Scheduler emulator en Azurite in voor lokale ontwikkeling.
  • Bouw en voer de functie-app uit en activeer beide orchestraties.
  • Controleer de orchestratiestatus en uitvoer in het dashboard van Durable Task Scheduler.

Prerequisites

De emulator voor Durable Task Scheduler instellen

De Durable Task Scheduler-emulator biedt een lokale ontwikkelomgeving, zodat u indelingen kunt testen zonder een Azure abonnement. De Java Functions-host vereist ook Azurite voor lokale opslag.

Start beide containers op:

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

Tip

Zodra de emulator actief is, kunt u het Durable Task Scheduler-dashboard openen op http://localhost:8082 om orchestraties te bewaken.

Het snelstartvoorbeeld uitvoeren

  1. Navigeer naar de voorbeeldmap Hello Cities:

    cd samples/durable-functions/java/HelloCities

  2. Controleer of het local.settings.json bestand de volgende configuratie bevat:

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

  3. Bouw het project:

    mvn clean package

  4. Start de functie-app:

    mvn azure-functions:run

  5. Start in een aparte terminal de orkestratie van functiechaining:

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

    Het antwoord bevat status-URL's voor de orchestratie-instantie. Kopieer de waarde statusQueryGetUri en voer deze uit om het resultaat te controleren:

    Invoke-RestMethod -Uri $response.statusQueryGetUri

  6. Start de fan-out/fan-in-orchestratie:

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

Verwachte uitvoer

De POST-aanvraag retourneert een JSON-antwoord met status-URL's. Voorbeeld:

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

Wanneer u een query uitvoert op statusQueryGetUri en de runtimeStatus van de orchestratie Completed is, kunt u de resultaten van de begroeting vinden in het veld output. De ketenorkestratie retourneert:

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

De fan-out/fan-in-orchestratie retourneert:

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

Tip

Als runtimeStatusRunning of Pending weergeeft, wacht dan even en voer de statusQueryGetUri opnieuw uit.

Open het dashboard van Durable Task Scheduler op http://localhost:8082 om de orchestrationstatus en uitvoeringsgeschiedenis te bekijken.

De code begrijpen

Het voorbeeldproject in src/main/java/com/example/Functions.java bevat alle drie de functietypen die nodig zijn voor een Durable Functions-app.

Activiteitsfunctie

De SayHello activiteit heeft een plaatsnaam en retourneert een begroeting:

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

Orchestratorfuncties

De chaining orchestrator roept SayHello opeenvolgend aan voor drie steden:

@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;
}

De fan-out/fan-in orchestrator plant activiteiten parallel:

@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;
}

Clientfuncties

Door HTTP geactiveerde clientfuncties starten elke orchestratie:

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

Configuratie

In het voorbeeld wordt de Durable Task Scheduler-emulator gebruikt als de back-end voor opslag. Dit is geconfigureerd in host.json:

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

De verbindingsreeks voor de emulator is ingesteld in local.settings.json:

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

De hulpbronnen opschonen

Stop de containers van de emulator wanneer u klaar bent:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Volgende stappen 

  • Last updated on