Guida introduttiva: Creare un'applicazione Durable Functions in JavaScript

Usare Durable Functions, una funzionalità di Funzioni di Azure, per scrivere flussi di lavoro serverless con stato in JavaScript. In questa guida introduttiva si clona ed esegue un'app di esempio che illustra due modelli di orchestrazione comuni:

  • Concatenamento delle funzioni: chiama le attività in sequenza (Tokyo → Seattle → Londra).
  • Fan-out/fan-in: chiama le attività in parallelo tra cinque città, quindi aggrega i risultati.

Alla fine, avrai entrambe le orchestrazioni in esecuzione in locale con l'emulatore Durable Task Scheduler e potrai visualizzarne lo stato nella dashboard.

  • Clonare e preparare il progetto di esempio Hello Cities.
  • Configurare l'emulatore Durable Task Scheduler e Azurite per lo sviluppo locale.
  • Eseguire l'app per le funzioni e attivare entrambe le orchestrazioni.
  • Esamina lo stato dell'orchestrazione e il relativo output nel dashboard di Durable Task Scheduler.

Prerequisiti

Configurare l'emulatore dell'utilità di pianificazione di Durable Task

L'emulatore Durable Task Scheduler fornisce un ambiente di sviluppo locale che consente di testare le orchestrazioni senza un abbonamento di Azure. L'host funzioni richiede anche Azurite per l'archiviazione locale.

Avviare entrambi i contenitori:

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

Una volta avviato l'emulatore, è possibile accedere al dashboard di Durable Task Scheduler all'indirizzo http://localhost:8082 per monitorare le orchestrazioni.

Eseguire l'esempio di avvio rapido

  1. Vai alla directory di esempio di Hello Cities:

    cd samples/durable-functions/javascript/HelloCities

  2. Installare le dipendenze:

    npm install

  3. Verificare che il local.settings.json file contenga la configurazione seguente:

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

  4. Avviare l'app per le funzioni:

    func start

  5. In un terminale separato attivare l'orchestrazione del concatenamento delle funzioni :

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

    La risposta contiene gli URL di stato per l'istanza di orchestrazione. Copiare il statusQueryGetUri valore ed eseguirlo per controllare il risultato:

    Invoke-RestMethod -Uri $response.statusQueryGetUri

  6. Attiva l'orchestrazione fan-out/fan-in:

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

Output previsto

La richiesta POST restituisce una risposta JSON con URL di stato. Per esempio:

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

Quando si interroga statusQueryGetUri e il campo runtimeStatus dell'orchestrazione è Completed, è possibile trovare i risultati del saluto nel campo output. L'orchestrazione del concatenamento restituisce:

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

L'orchestrazione fan-out/fan-in restituisce:

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

Tip

Se runtimeStatus mostra Running o Pending, attendere un attimo ed eseguire di nuovo una statusQueryGetUri query.

Apri il dashboard di Durable Task Scheduler all'indirizzo http://localhost:8082 per visualizzare lo stato dell'orchestrazione e la cronologia di esecuzione.

Informazioni sul codice

L'esempio usa il modello di programmazione Node.js v4, in cui tutte le funzioni sono definite in un singolo file (src/functions/helloCities.js).

Funzione dell'attività

L'attività sayHello prende il nome di una città e restituisce un saluto:

df.app.activity("sayHello", {
  handler: (city) => {
    return `Hello ${city}!`;
  },
});

Funzioni dell'agente di orchestrazione

L'orchestratore di concatenazione chiama sayHello in sequenza per tre città:

df.app.orchestration("chainingOrchestration", function* (context) {
  const outputs = [];
  outputs.push(yield context.df.callActivity("sayHello", "Tokyo"));
  outputs.push(yield context.df.callActivity("sayHello", "Seattle"));
  outputs.push(yield context.df.callActivity("sayHello", "London"));
  return outputs;
});

L'orchestratore fan-out/fan-in pianifica le attività in parallelo:

df.app.orchestration("fanOutFanInOrchestration", function* (context) {
  const cities = ["Tokyo", "Seattle", "London", "Paris", "Berlin"];

  // Fan-out: schedule all activities in parallel
  const tasks = cities.map((city) => context.df.callActivity("sayHello", city));

  // Fan-in: wait for all to complete
  const results = yield context.df.Task.all(tasks);
  return results;
});

Funzioni del client

Le funzioni client attivate da HTTP avviano ogni orchestrazione. Ad esempio, l'avvio della concatenazione:

app.http("StartChaining", {
  route: "StartChaining",
  methods: ["POST"],
  authLevel: "anonymous",
  extraInputs: [df.input.durableClient()],
  handler: async (request, context) => {
    const client = df.getClient(context);
    const instanceId = await client.startNew("chainingOrchestration");
    context.log(`Started chaining orchestration with ID = '${instanceId}'.`);
    return client.createCheckStatusResponse(request, instanceId);
  },
});

Configurazione

L'esempio usa l'emulatore di Durable Task Scheduler come backend di archiviazione. Questa operazione è configurata in host.json:

{
  "version": "2.0",
  "logging": {
    "logLevel": {
      "DurableTask.Core": "Warning"
    }
  },
  "extensions": {
    "durableTask": {
      "hubName": "default",
      "storageProvider": {
        "type": "azureManaged",
        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

Pulire le risorse

Quando avete finito, fermate i contenitori dell'emulatore:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Passaggi successivi

  • Last updated on