Inicio rápido: Creación de una aplicación de Java Durable Functions

Use Durable Functions, una característica de Azure Functions, para escribir flujos de trabajo sin servidor con estado en Java. En este inicio rápido, clonará y ejecutará una aplicación de ejemplo que muestra dos patrones de orquestación comunes:

  • Encadenamiento de funciones: llama a actividades secuencialmente (Tokio → Seattle → Londres).
  • Fan-out/fan-in: invoca actividades en paralelo en cinco ciudades y, a continuación, agrega los resultados.

Al final, tendrás ambas orquestaciones ejecutándose en local con el emulador Durable Task Scheduler y podrás ver su estado en el panel de control.

  • Clona y prepara el proyecto de ejemplo Hello Cities.
  • Configure el emulador de Durable Task Scheduler y Azurite para el desarrollo local.
  • Compile y ejecute la aplicación de funciones y desencadene ambas orquestaciones.
  • Consulte el estado y el resultado de la orquestación en el panel de Durable Task Scheduler.

Prerrequisitos

Configuración del emulador del Programador de tareas duraderas

El emulador del programador de tareas de Durable proporciona un entorno de desarrollo local para que pueda probar orquestaciones sin una suscripción Azure. El host Java Functions también requiere Azurite para el almacenamiento local.

Inicie ambos contenedores:

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

Sugerencia

Una vez que el emulador esté en ejecución, puede acceder al panel de Durable Task Scheduler en http://localhost:8082 para supervisar las orquestaciones.

Ejecución del ejemplo de inicio rápido

  1. Vaya al directorio de ejemplo Hello Cities:

    cd samples/durable-functions/java/HelloCities

  2. Compruebe que el local.settings.json archivo contiene la siguiente configuración:

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

  3. Compile el proyecto:

    mvn clean package

  4. Inicie la aplicación de funciones:

    mvn azure-functions:run

  5. En un terminal independiente, active la orquestación del encadenamiento de funciones:

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

    La respuesta contiene direcciones URL de estado para la instancia de orquestación. Copie el statusQueryGetUri valor y ejecútelo para comprobar el resultado:

    Invoke-RestMethod -Uri $response.statusQueryGetUri

  6. Inicie la orquestación fan-out/fan-in:

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

Salida prevista

La solicitud POST devuelve una respuesta JSON con direcciones URL de estado. Por ejemplo:

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

Cuando consulte statusQueryGetUri y la runtimeStatus de la orquestación sea Completed, podrá encontrar los resultados del saludo en el campo output. La orquestación en cadena devuelve:

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

La orquestación fan-out/fan-in devuelve:

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

Sugerencia

Si runtimeStatus muestra Running o Pending, espere un momento y vuelva a consultarlo statusQueryGetUri .

Abra el panel del Programador de tareas durables en http://localhost:8082 para ver el estado de orquestación y el historial de ejecución.

Descripción del código

El proyecto de ejemplo de src/main/java/com/example/Functions.java contiene los tres tipos de función necesarios para una aplicación de Durable Functions.

Función de actividad

La SayHello actividad toma un nombre de ciudad y devuelve un saludo:

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

Funciones del Orquestador

El orquestador de cadenas invoca SayHello secuencialmente para tres ciudades:

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

El orquestador fan-out/fan-in programa actividades en paralelo:

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

Funciones de cliente

Las funciones de cliente desencadenadas por HTTP inician cada orquestación:

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

Configuración

En el ejemplo se usa el emulador de Durable Task Scheduler como back-end de almacenamiento. Esto se configura en host.json:

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

El cadena de conexión del emulador se establece en local.settings.json:

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

Limpieza de recursos

Detenga los contenedores del emulador cuando haya terminado:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Pasos siguientes

  • Last updated on