Schnellstart: Erstellen einer TypeScript-Durable Functions-App

Verwenden Sie Durable Functions, ein Feature von Azure Functions, um zustandslose serverlose Workflows in TypeScript zu schreiben. In dieser Schnellstartanleitung klonen und führen Sie eine Beispiel-App aus, die zwei gängige Orchestrierungsmuster veranschaulicht:

• Funktionskette: Ruft Aktivitäten sequenziell auf (Tokio → Seattle → London).
• Fan-out/Fan-In: Ruft Aktivitäten parallel in fünf Städten auf und aggregiert dann die Ergebnisse.

Am Ende haben Sie beide Orchestrierungen lokal mit dem Emulator " Durable Task Scheduler " ausgeführt und können ihren Status im Dashboard anzeigen.

Voraussetzungen

• Node.js 20+ installiert.
• Azure Functions Core Tools v4 oder höher.
• Docker für die Ausführung des Emulators und der Azurite.
• Klonen Sie den Durable Task Scheduler GitHub Repository, um das Schnellstartbeispiel zu verwenden.

Einrichten des Emulators "Durable Task Scheduler"

Der Emulator Durable Task Scheduler stellt eine lokale Entwicklungsumgebung bereit, sodass Sie Orchestrierungen ohne Azure Abonnement testen können. Der Functions-Host erfordert auch Azurite für den lokalen Speicher.

Starten Sie beide Container:

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

Ausführen des Schnellstartbeispiels

1. Navigieren Sie zum Beispielverzeichnis "Hello Cities":

   cd samples/durable-functions/typescript/HelloCities
   

2. Installieren Sie Abhängigkeiten, und erstellen Sie das Projekt:

   npm install
   npm run build
   

3. Stellen Sie sicher, dass die local.settings.json Datei die folgende Konfiguration enthält:

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

4. Starten Sie die Funktions-App:

   func start
   

5. Starten Sie in einem separaten Terminal die Orchestrierung der Verkettung von Funktionen:

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

   Die Antwort enthält Status-URLs für die Orchestrierungsinstanz. Kopieren Sie den statusQueryGetUri Wert, und führen Sie ihn aus, um das Ergebnis zu überprüfen:

   Invoke-RestMethod -Uri $response.statusQueryGetUri
   

6. Auslösen der Fanout-/Fan-In-Orchestrierung :

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

Erwartete Ausgabe

Die POST-Anforderung gibt eine JSON-Antwort mit Status-URLs zurück. Zum Beispiel:

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

Wenn Sie statusQueryGetUri abfragen und der runtimeStatus der Orchestrierung Completed ist, finden Sie die Begrüßungsergebnisse im Feld output. Die Verkettungs-Orchestrierung gibt Folgendes zurück:

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

Die Fan-out/Fan-in-Orchestrierung liefert Folgendes zurück:

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

Öffnen Sie das Durable Task Scheduler-Dashboard unter http://localhost:8082, um den Orchestrierungsstatus und den Ausführungsverlauf einzusehen.

Grundlegendes zum Code

Im Beispiel wird das Node.js v4-Programmiermodell verwendet, in dem alle Funktionen in einer einzelnen Datei (src/functions/helloCities.ts) definiert sind.

Aktivitätsfunktion

Die sayHello Aktivität nimmt einen Stadtnamen und gibt eine Begrüßung zurück:

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

Orchestratorfunktionen

Der Verkettungs-Orchestrator ruft sequenziell für drei Städte auf sayHello :

const chainingOrchestrator: OrchestrationHandler = function* (
  context: OrchestrationContext
) {
  const outputs: string[] = [];
  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;
};
df.app.orchestration("chainingOrchestration", chainingOrchestrator);

Der Fan-out/Fan-in-Orchestrator plant Aktivitäten parallel:

const fanOutFanInOrchestrator: OrchestrationHandler = function* (
  context: OrchestrationContext
) {
  const cities: string[] = ["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: string[] = yield context.df.Task.all(tasks);
  return results;
};
df.app.orchestration("fanOutFanInOrchestration", fanOutFanInOrchestrator);

Clientfunktionen

Durch HTTP ausgelöste Clientfunktionen starten jede Orchestrierung. Beispiel: Der Verkettungsstarter:

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

Konfiguration

Im Beispiel wird der Emulator "Durable Task Scheduler" als Speicher-Back-End verwendet. Dies ist konfiguriert 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)"
  }
}

Bereinigen von Ressourcen

Beenden Sie die Emulatorcontainer, wenn Sie fertig sind:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Nächste Schritte

• Erfahren Sie mehr über common Durable Functions App-Muster.
• Erfahren Sie mehr über Durable Functions Speicheranbieter.