Snabbstart: Skapa en TypeScript-Durable Functions-app

Använd Durable Functions, en funktion i Azure Functions, för att skriva tillståndskänsliga serverlösa arbetsflöden i TypeScript. I den här snabbstarten ska du klona och köra en exempelapp som visar två vanliga orkestreringsmönster:

Funktionskedjning: Anropar aktiviteter i följd (Tokyo → Seattle → London).
Fan-out/fan-in: Anropar aktiviteter parallellt i fem städer och sammanställer sedan resultatet.

När du är klar kommer båda orkestreringarna att köras lokalt med Durable Task Scheduler-emulatorn, och du kan se deras status på instrumentpanelen.

Klona och förbered Hello Cities-exempelprojektet.
Konfigurera Durable Task Scheduler-emulatorn och Azurite för lokal utveckling.
Kör funktionsappen och utlös båda orkestreringarna.
Granska orkestreringsstatus och utdata i instrumentpanelen för Durable Task Scheduler.

Förutsättningar

Node.js 20+ installerat.
Azure Functions Core Tools v4 eller senare.
Docker för att köra emulatorn och Azurite.
Klona Durable Task Scheduler GitHub-lagringsplatsen för att använda snabbstartsexemplet.

Konfigurera Durable Task Scheduler-emulatorn

Durable Task Scheduler-emulatorn tillhandahåller en lokal utvecklingsmiljö så att du kan testa orkestreringar utan en Azure prenumeration. Värden för Functions kräver också Azurite för lokal lagring.

Starta båda containrarna:

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

När emulatorn körs kan du komma åt instrumentpanelen Durable Task Scheduler på http://localhost:8082 för att övervaka orkestreringar.

Kör snabbstartsexemplet

Gå till exempelkatalogen Hello Cities:

cd samples/durable-functions/typescript/HelloCities

Installera beroenden och skapa projektet:
```
npm install
npm run build
```

Kontrollera att local.settings.json filen innehåller följande konfiguration:

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

Starta funktionsappen:
```
func start
```
I en separat terminal utlöser du orkestreringen för funktionskedjning:
```
$response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartChaining
$response
```
Svaret innehåller status-URL:er för orkestreringsinstansen. Kopiera värdet statusQueryGetUri och kör det för att kontrollera resultatet:
```
Invoke-RestMethod -Uri $response.statusQueryGetUri
```

Utlös fan-out/fan-in-orkestreringen :

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

Förväntade utdata

POST-begäran returnerar ett JSON-svar med status-URL:er. Ett exempel:

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

När du frågar efter statusQueryGetUri och orkestreringens runtimeStatus är Completed, kan du hitta hälsningsresultaten i fältet output. Orkestreringen för kedjning returnerar:

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

Fan-out/fan-in-orkestreringen returnerar:

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

Tip

Om runtimeStatus visar Running eller Pendingväntar du en stund och frågar statusQueryGetUri igen.

Öppna instrumentpanelen för Durable Task Scheduler på http://localhost:8082 för att se orkestreringsstatus och körningshistorik.

Förstå koden

Exemplet använder programmeringsmodellen Node.js v4, där alla funktioner definieras i en enda fil (src/functions/helloCities.ts).

Aktivitetsfunktion

Aktiviteten sayHello tar ett stadsnamn och returnerar en hälsning:

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

Orkestratorfunktioner

Kedjeorkestreraren anropar sayHello sekventiellt för tre städer:

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

Fan-out/fan-in orchestrator schemalägger aktiviteter parallellt:

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

Klientfunktioner

Klientfunktioner som utlöses via HTTP startar varje orkestrering. Till exempel kedjestartaren:

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

Exemplet använder Durable Task Scheduler-emulatorn som lagringsbackend. Detta konfigureras i 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)"
  }
}

Rensa resurser

Stoppa emulatorcontainrarna när du är klar:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Nästa steg

Läs mer om vanliga Durable Functions applikationsmönster.
Lär dig mer om Durable Functions lagringsproviders.

Feedback

Var den här sidan till hjälp?

Last updated on 2026-06-05