Szybki start: tworzenie aplikacji Durable Functions TypeScript

Użyj Durable Functions, funkcji usługi Azure Functions, do tworzenia bezserwerowych przepływów pracy z zachowaniem stanu w języku TypeScript. W tym przewodniku szybkiego startu sklonujesz i uruchomisz przykładową aplikację, która przedstawia dwa typowe wzorce orkiestracji:

  • Łańcuch funkcji: sekwencyjnie wywołuje działania (Tokio → Seattle → Londynie).
  • Fan-out/fan-in: Wywołuje działania równolegle w pięciu miastach, a następnie agreguje wyniki.

Na koniec obie orkiestracje będą uruchomione lokalnie z użyciem emulatora Durable Task Scheduler, a Ty będziesz mieć możliwość wyświetlenia ich stanu w pulpicie nawigacyjnym.

  • Sklonuj i przygotuj przykładowy projekt Hello Cities.
  • Skonfiguruj emulator narzędzia Durable Task Scheduler i Azurite na potrzeby programowania lokalnego.
  • Uruchom aplikację funkcji i uruchom obie orkiestracje.
  • Przejrzyj stan orkiestracji i dane wyjściowe na pulpicie nawigacyjnym narzędzia Durable Task Scheduler.

Wymagania wstępne

Konfigurowanie emulatora harmonogramu zadań Durable Task Scheduler

Emulator harmonogramu zadań Durable udostępnia lokalne środowisko programistyczne, dzięki czemu można testować aranżacje bez subskrypcji Azure. Host usługi Functions wymaga również Azurite do magazynowania lokalnego.

Uruchom oba kontenery:

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

Wskazówka

Po uruchomieniu emulatora możesz uzyskać dostęp do pulpitu nawigacyjnego narzędzia Durable Task Scheduler pod adresem , http://localhost:8082 aby monitorować aranżacje.

Uruchamianie przykładu szybkiego startu

  1. Przejdź do przykładowego katalogu Hello Cities:

    cd samples/durable-functions/typescript/HelloCities

  2. Zainstaluj zależności i skompiluj projekt:

    npm install
npm run build

  3. Sprawdź, czy local.settings.json plik zawiera następującą konfigurację:

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

  4. Uruchom aplikację funkcji:

    func start

  5. W osobnym terminalu wyzwól orkiestrację łańcucha funkcji :

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

    Odpowiedź zawiera adresy URL stanu instancji orkiestracji. statusQueryGetUri Skopiuj wartość i uruchom ją, aby sprawdzić wynik:

    Invoke-RestMethod -Uri $response.statusQueryGetUri

  6. Uruchom orkiestrację fan-out/fan-in:

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

Oczekiwane dane wyjściowe

Żądanie POST zwraca odpowiedź w formacie JSON z adresami URL statusu. Przykład:

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

Gdy wykonasz zapytanie dotyczące statusQueryGetUri i wartość runtimeStatus orkiestracji to Completed, możesz znaleźć wyniki powitania w polu output. Orkiestracja łańcuchowa zwraca:

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

Orkiestracja fan-out/fan-in zwraca następujące wartości:

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

Wskazówka

Jeśli runtimeStatus wyświetla Running lub Pending, zaczekaj chwilę i ponownie odpytaj statusQueryGetUri.

Otwórz pulpit nawigacyjny harmonogramu zadań Durable Task Scheduler pod adresem http://localhost:8082, aby wyświetlić stan orkiestracji i historię wykonania.

Omówienie kodu

W przykładzie użyto modelu programowania Node.js w wersji 4, w którym wszystkie funkcje są definiowane w jednym pliku (src/functions/helloCities.ts).

Funkcja aktywności

Działanie sayHello przyjmuje nazwę miasta i zwraca powitanie:

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

Funkcje programu Orchestrator

Orkiestrator łańcuchowy sekwencyjnie wywołuje sayHello dla trzech miast:

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

Orkiestrator fan-out/fan-in planuje działania równolegle:

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

Funkcje klienta

Funkcje klienta wyzwalane przez protokół HTTP uruchamiają każdą aranżację. Na przykład inicjator łańcuchowania:

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

Konfiguracja

W przykładzie użyto emulatora Durable Task Scheduler jako zaplecza magazynującego. Jest to skonfigurowane w programie 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)"
  }
}

Uprzątnij zasoby

Zatrzymaj kontenery emulatora, gdy skończysz:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Następne kroki

  • Last updated on