Schnellstart: Erstellen eines serverlosen Workflows mithilfe von Durable Functions

In dieser Schnellstartanleitung verwenden Sie Azure Developer-Befehlszeilentools, um einen serverlosen Workflow zu erstellen, der mehrere parallel ausgeführte Aufgaben koordiniert. Sie erstellen Ressourcen in Azure, überprüfen den Code lokal und deployen ihn dann in einer neuen serverlosen Funktions-App, die in einem Flex-Consumption-Plan in Azure Functions läuft.

Das Projekt verwendet die Azure Developer CLI (azd), um die Bereitstellung Ihres Codes für Azure zu vereinfachen. Diese Bereitstellung folgt den aktuellen bewährten Methoden für sichere und skalierbare Azure Functions Bereitstellungen. In dieser Schnellstartanleitung wird das Fan-Out/Fan-In-Muster in Durable Functions veranschaulicht. Es handelt sich dabei um eine Erweiterung, die zustandsbehaftete Workflows mit permanenter Ausführung orchestriert. Das Beispiel verwendet den Durable Task Scheduler, ein vollständig verwaltetes Backend für Durable Functions, das das Azure Storage-Backend ersetzt. Das Beispiel ruft Artikeltitel parallel ab: Die Orchestrierung wird in mehrere gleichzeitig ausgeführte Aktivitäten unterteilt (Fan-Out). Anschließend werden die Ergebnisse wieder zu einem einzigen Ergebnis kombiniert (Fan-In).

Standardmäßig folgt der Flex-Verbrauchsplan einem Abrechnungsmodell nach dem Prinzip 'Bezahlen nach Nutzung'. Dies bedeutet, dass bei diesem Quickstart ein kleiner Betrag von ein paar US-Cent oder weniger in Ihrem Azure-Konto anfallen wird.

Voraussetzungen

Initialisieren des Projekts

Verwenden Sie den Befehl azd init, um ein lokales Durable Functions-Codeprojekt aus einer Vorlage zu erstellen.

  1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

    azd init --template durable-functions-quickstart-dotnet-azd -e dfquickstart-dotnet

    Mit diesem Befehl werden die Projektdateien aus dem Repository template abgerufen und das Projekt in einem neuen Ordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Der Umgebungsname wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

  2. Wechsle ins Projektverzeichnis und navigiere dann zum fanoutfanin App-Ordner:

    cd durable-functions-quickstart-dotnet-azd/fanoutfanin

  1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

    azd init --template durable-functions-quickstart-python-azd -e dfquickstart-python

    Mit diesem Befehl werden die Projektdateien aus dem Repository template abgerufen und das Projekt in einem neuen Ordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Der Umgebungsname wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

  2. Wechsle ins Projektverzeichnis und navigiere dann zum src App-Ordner:

    cd durable-functions-quickstart-python-azd/src

  1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

    azd init --template durable-functions-quickstart-typescript-azd -e dfquickstart-typescript

    Mit diesem Befehl werden die Projektdateien aus dem Repository template abgerufen und das Projekt in einem neuen Ordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Der Umgebungsname wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

  2. Wechsle ins Projektverzeichnis und navigiere dann zum src App-Ordner:

    cd durable-functions-quickstart-typescript-azd/src

  1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

    azd init --template durable-functions-quickstart-java-azd -e dfquickstart-java

    Mit diesem Befehl werden die Projektdateien aus dem Repository template abgerufen und das Projekt in einem neuen Ordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Der Umgebungsname wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

  2. Wechseln Sie in das Projektverzeichnis:

    cd durable-functions-quickstart-java-azd

  1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

    azd init --template durable-functions-quickstart-javascript-azd -e dfquickstart-javascript

    Mit diesem Befehl werden die Projektdateien aus dem Repository template abgerufen und das Projekt in einem neuen Ordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Der Umgebungsname wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

  2. Wechsle ins Projektverzeichnis und navigiere dann zum src App-Ordner:

    cd durable-functions-quickstart-javascript-azd/src

  1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diesen azd init-Befehl in einem leeren Ordner aus:

    azd init --template durable-functions-quickstart-powershell-azd -e dfquickstart-powershell

    Mit diesem Befehl werden die Projektdateien aus dem Repository template abgerufen und das Projekt in einem neuen Ordner initialisiert. Das -e-Flag legt einen Namen für die aktuelle Umgebung fest. In azdder Umgebung wird ein eindeutiger Bereitstellungskontext für Ihre App verwaltet, und Sie können mehrere definieren. Der Umgebungsname wird auch im Namen der Ressourcengruppe verwendet, die Sie in Azure erstellen.

  2. Wechsle ins Projektverzeichnis und navigiere dann zum src App-Ordner:

    cd durable-functions-quickstart-powershell-azd/src

Bereitstellen von Azure-Ressourcen

Dieses Projekt verwendet den azd provision Befehl, um die erforderlichen Azure-Ressourcen zu erstellen, darunter eine neue Funktions-App in einem Flex-Consumption-Plan, einen Durable Task Scheduler und einen Task-Hub.

Tip

Das Projekt enthält ein Set von Bicep-Dateien (im Ordner infra), die azd verwendet, um eine sichere Bereitstellung für einen Flex-Verbrauchsplan zu erstellen, der bewährten Verfahren folgt.

  1. Gehe zurück zum Root-Projektordner (dem Ordner, der die azure.yaml Datei enthält):

    cd ..
  1. Stelle sicher, dass du dich noch im Root-Projektordner befindest (dem Ordner, der die azure.yaml Datei enthält).

  1. Führe diesen Befehl aus, um dich mit deinem Azure-Konto zu authentifizieren:

    azd auth login

  2. Führe diesen Befehl aus dem Root-Projektordner aus, um azd die erforderlichen Azure-Ressourcen zu erstellen:

    azd provision

    Der Stammordner enthält die azure.yaml-Definitionsdatei, die azd erfordert.

  3. Wenn Sie dazu aufgefordert werden, stellen Sie die folgenden erforderlichen Bereitstellungsparameter bereit:

    Parameter Description
    Azure-Abonnement Das Abonnement, in dem Ihre Ressourcen erstellt werden. Wenn dein Konto mehr als einen Mieter hat, musst du zuerst deinen Mieter auswählen.
    Azure-Standort Azure Region, in der die Ressourcengruppe erstellt werden soll, die die neuen Azure Ressourcen enthält. Es werden nur Regionen angezeigt, die den Flex-Verbrauchsplan derzeit unterstützen.
    vnetEnabled Ob in einem virtuellen Netzwerk bereitgestellt werden soll. Für diesen Quickstart wählen Sie falsch aus.

    Der azd provision Befehl verwendet Ihre Antworten auf diese Prompts mit den Bicep-Konfigurationsdateien, um diese erforderlichen Azure-Ressourcen zu erstellen und zu konfigurieren:

    • Flex-Verbrauchsplan und Funktionsanwendung
    • Azure Storage (erforderlich) und Application Insights (empfohlen)
    • Durable Task Scheduler und Aufgabenhub
    • Zugriffsrichtlinien und -rollen für Ihr Konto
    • Dienst-zu-Dienst-Verbindungen mit verwalteten Identitäten (anstelle gespeicherter Verbindungszeichenfolgen)

    Nachdem der Befehl erfolgreich abgeschlossen wurde, werden Links zu den von Ihnen erstellten Ressourcen angezeigt.

    Die Provisionierung führt außerdem ein Post-Provision-Skript aus, das eine local.settings.json-Datei in deinem App-Ordner generiert. Diese Datei enthält die Verbindungseinstellungen für den bereitgestellten Durable Task Scheduler-Endpunkt, den Sie benötigen, um das Projekt lokal auszuführen.

Starten Sie Azurite

Um das Projekt lokal auszuführen, benötigt die Functions-Laufzeit einen lokalen Speicheremulator. Die "AzureWebJobsStorage": "UseDevelopmentStorage=true" Einstellung in der local.settings.json-Datei weist die Laufzeit an, Azurite für diesen Zweck zu verwenden.

Führe in einem neuen Terminalfenster diesen Befehl aus, um Azurite zu starten:

azurite --skipApiVersionCheck --location ~/azurite-data

Lassen Sie Azurite in diesem Terminalfenster laufen, während Sie lokal testen.

Ausführen in Ihrer lokalen Umgebung

  1. Gehe in deinem ursprünglichen Terminal in den fanoutfanin App-Ordner und starte den Funktionen-Host:

    cd fanoutfanin
func start

    Wenn der Funktionshost in Ihrem lokalen Projektordner gestartet wird, schreibt er die lokalen URL-Endpunkte Ihrer HTTP-ausgelösten Funktionen in die Terminalausgabe.

    Note

    Da die Zugriffstastenautorisierung bei der lokalen Ausführung nicht erzwungen wird, benötigen Sie keine Zugriffstaste, um Ihre Funktion aufzurufen.

  2. Nehmen Sie in Ihrem Browser eine GET-Anforderung an den Endpunkt vor, der die Orchestrierung startet:

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Diese Anforderung startet eine neue Orchestrierungsinstanz. Die Orchestrierung wird auf mehrere Aktivitäten unterteilt, damit die Titel der Microsoft Learn-Artikel parallel abgerufen werden können. Nach Beendigen der Aktivitäten gibt die Orchestrierung im Fan-In-Modus die Titel als formatierte Zeichenfolge zurück.

  1. Gehe in deinem ursprünglichen Terminal in den src App-Ordner, erstelle und aktiviere eine virtuelle Umgebung, installiere Abhängigkeiten und starte den Functions-Host:

    cd src

    Die Art und Weise, wie du deine virtuelle Umgebung (benannt) erstellst und aktivierst, hängt von deinem Terminal .venvab:

    python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
func start

    Wenn der Funktionshost in Ihrem lokalen Projektordner gestartet wird, schreibt er die lokalen URL-Endpunkte Ihrer HTTP-ausgelösten Funktionen in die Terminalausgabe.

    Note

    Da die Zugriffstastenautorisierung bei der lokalen Ausführung nicht erzwungen wird, benötigen Sie keine Zugriffstaste, um Ihre Funktion aufzurufen.

  2. Nehmen Sie in Ihrem Browser eine GET-Anforderung an den HTTP-Startendpunkt vor:

    http://localhost:7071/api/orchestrators/fetch_orchestration

    Diese Anforderung startet eine neue Orchestrierungsinstanz. Die Orchestrierung wird auf mehrere Aktivitäten unterteilt, damit die Titel der Microsoft Learn-Artikel parallel abgerufen werden können. Nach Beendigen der Aktivitäten gibt die Orchestrierung im Fan-In-Modus die Titel als formatierte Zeichenfolge zurück.

  1. Gehe in deinem ursprünglichen Terminal in den src App-Ordner, installiere Abhängigkeiten, baue das Projekt und starte den Functions-Host:

    cd src
npm install
npm run build
func start

    Wenn der Funktionshost in Ihrem lokalen Projektordner gestartet wird, schreibt er die lokalen URL-Endpunkte Ihrer HTTP-ausgelösten Funktionen in die Terminalausgabe.

    Note

    Da die Zugriffstastenautorisierung bei der lokalen Ausführung nicht erzwungen wird, benötigen Sie keine Zugriffstaste, um Ihre Funktion aufzurufen.

  2. Nehmen Sie in Ihrem Browser eine GET-Anforderung an den HTTP-Startendpunkt vor:

    http://localhost:7071/api/orchestrators/fetchOrchestration

    Diese Anforderung startet eine neue Orchestrierungsinstanz. Die Orchestrierung wird auf mehrere Aktivitäten unterteilt, damit die Titel der Microsoft Learn-Artikel parallel abgerufen werden können. Nach Beendigen der Aktivitäten gibt die Orchestrierung im Fan-In-Modus die Titel als formatierte Zeichenfolge zurück.

  1. Baue in deinem ursprünglichen Terminal das Projekt und starte dann den Functions-Host aus dem Build-Ausgabeordner:

    mvn clean package
cd target/azure-functions/durable-functions-quickstart
func start

    Wenn der Funktionshost in Ihrem lokalen Projektordner gestartet wird, schreibt er die lokalen URL-Endpunkte Ihrer HTTP-ausgelösten Funktionen in die Terminalausgabe.

    Note

    Da die Zugriffstastenautorisierung bei der lokalen Ausführung nicht erzwungen wird, benötigen Sie keine Zugriffstaste, um Ihre Funktion aufzurufen.

  2. Nehmen Sie in Ihrem Browser eine GET-Anforderung an den Endpunkt vor, der die Orchestrierung startet:

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Diese Anforderung startet eine neue Orchestrierungsinstanz. Die Orchestrierung wird auf mehrere Aktivitäten unterteilt, damit die Titel der Microsoft Learn-Artikel parallel abgerufen werden können. Nach Beendigen der Aktivitäten gibt die Orchestrierung im Fan-In-Modus die Titel als formatierte Zeichenfolge zurück.

  1. Gehe in deinem ursprünglichen Terminal in den src App-Ordner, installiere Abhängigkeiten und starte den Functions-Host:

    cd src
npm install
func start

    Wenn der Funktionshost in Ihrem lokalen Projektordner gestartet wird, schreibt er die lokalen URL-Endpunkte Ihrer HTTP-ausgelösten Funktionen in die Terminalausgabe.

    Note

    Da die Zugriffstastenautorisierung bei der lokalen Ausführung nicht erzwungen wird, benötigen Sie keine Zugriffstaste, um Ihre Funktion aufzurufen.

  2. Nehmen Sie in Ihrem Browser eine GET-Anforderung an den Endpunkt vor, der die Orchestrierung startet:

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Diese Anforderung startet eine neue Orchestrierungsinstanz. Die Orchestrierung wird auf mehrere Aktivitäten unterteilt, damit die Titel der Microsoft Learn-Artikel parallel abgerufen werden können. Nach Beendigen der Aktivitäten gibt die Orchestrierung im Fan-In-Modus die Titel als formatierte Zeichenfolge zurück.

  1. Gehe in deinem ursprünglichen Terminal in den src App-Ordner und starte den Funktionen-Host:

    cd src
func start

    Wenn der Funktionshost in Ihrem lokalen Projektordner gestartet wird, schreibt er die lokalen URL-Endpunkte Ihrer HTTP-ausgelösten Funktionen in die Terminalausgabe.

    Note

    Da die Zugriffstastenautorisierung bei der lokalen Ausführung nicht erzwungen wird, benötigen Sie keine Zugriffstaste, um Ihre Funktion aufzurufen.

  2. Nehmen Sie in Ihrem Browser eine GET-Anforderung an den Endpunkt vor, der die Orchestrierung startet:

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Diese Anforderung startet eine neue Orchestrierungsinstanz. Die Orchestrierung wird auf mehrere Aktivitäten unterteilt, damit die Titel der Microsoft Learn-Artikel parallel abgerufen werden können. Nach Beendigen der Aktivitäten gibt die Orchestrierung im Fan-In-Modus die Titel als formatierte Zeichenfolge zurück.

  1. Der HTTP-Endpunkt gibt eine JSON-Antwort mit mehreren URLs zurück. Der statusQueryGetUri Endpunkt stellt den Orchestrierungsstatus bereit.

  2. Kopieren Sie den statusQueryGetUri Wert, und fügen Sie ihn in Ihren Browser oder HTTP-Testtool ein, um den Status der Orchestrierung zu überprüfen. Wenn die Orchestrierung abgeschlossen ist, werden die abgerufenen Artikeltitel in der Antwort angezeigt.

  3. Wenn Sie fertig sind, drücken Sie STRG+C im Terminalfenster, um den func-Hostprozess zu beenden.

  1. Führen Sie deactivate aus, um die virtuelle Umgebung zu beenden.

Überprüfen des Codes (optional)

Sie können den Code überprüfen, der das Fan-out-/Fan-In-Muster implementiert:

Die Titelabrufaktivitäten werden mithilfe einer dynamischen Aufgabenliste nachverfolgt. Die Zeile await Task.WhenAll(parallelTasks); wartet darauf, dass alle aufgerufenen Aktivitäten, die gleichzeitig ausgeführt werden, abgeschlossen sind. Wenn alles abgeschlossen ist, werden alle Ausgaben zu einer Zeichenfolge formatiert und aggregiert.

[Function(nameof(FetchOrchestration))]
public static async Task<string> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    ILogger logger = context.CreateReplaySafeLogger(nameof(FetchOrchestration));
    logger.LogInformation("Fetching data.");
    var parallelTasks = new List<Task<string>>();
    
    // List of URLs to fetch titles from
    var urls = new List<string>
    {
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps",
    };

    // Run fetching tasks in parallel
    foreach (var url in urls)
    {
        Task<string> task = context.CallActivityAsync<string>(nameof(FetchTitleAsync), url);
        parallelTasks.Add(task);
    }
    
    // Wait for all the parallel tasks to complete before continuing
    await Task.WhenAll(parallelTasks);
   
    // Return fetched titles as a formatted string
    return string.Join("; ", parallelTasks.Select(t => t.Result));
}

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Die Titelabrufaktivitäten werden mithilfe einer dynamischen Aufgabenliste nachverfolgt. Die Zeile yield context.task_all(tasks) wartet darauf, dass alle aufgerufenen Aktivitäten, die gleichzeitig ausgeführt werden, abgeschlossen sind. Wenn alles abgeschlossen ist, werden alle Ausgaben zu einer Zeichenfolge formatiert und aggregiert.

    # List of URLs to fetch titles from
    urls = [
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps",
    ]
    
    # Run fetching tasks in parallel
    tasks = []
    for url in urls:
        task = context.call_activity("fetch_title", url)
        tasks.append(task)
    
    # Wait for all the parallel tasks to complete before continuing
    results = yield context.task_all(tasks)
    
    # Return fetched titles as a formatted string
    return "; ".join(results)


@myApp.activity_trigger(input_name="url")
async def fetch_title(url: str):
    """Activity function that fetches the title from a URL."""
    logger = logging.getLogger("FetchTitle")
    logger.info(f"Fetching from url {url}.")
    
    try:
        async with ClientSession() as session:

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Die Titelabrufaktivitäten werden mithilfe einer dynamischen Aufgabenliste nachverfolgt. Die Zeile yield context.df.Task.all(parallelTasks) wartet darauf, dass alle aufgerufenen Aktivitäten, die gleichzeitig ausgeführt werden, abgeschlossen sind. Wenn alles abgeschlossen ist, werden alle Ausgaben zu einer Zeichenfolge formatiert und aggregiert.

    const urls = [
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps",
    ];

    // Run fetching tasks in parallel
    const parallelTasks = [];
    for (const url of urls) {
        const task = context.df.callActivity(fetchTitleActivityName, url);
        parallelTasks.push(task);
    }

    // Wait for all the parallel tasks to complete before continuing
    const results: string[] = yield context.df.Task.all(parallelTasks);

    // Return fetched titles as a formatted string
    return results.join("; ");
};
df.app.orchestration("fetchOrchestration", fetchOrchestration);

const fetchTitleAsync: ActivityHandler = async function (
    url: string,
    context: InvocationContext

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Die Titelabrufaktivitäten werden mithilfe einer dynamischen Aufgabenliste nachverfolgt. Die Zeile ctx.allOf(parallelTasks).await() wartet darauf, dass alle aufgerufenen Aktivitäten, die gleichzeitig ausgeführt werden, abgeschlossen sind. Wenn alles abgeschlossen ist, werden alle Ausgaben zu einer Zeichenfolge formatiert und aggregiert.

@FunctionName("FetchOrchestration")
public String runOrchestrator(
        @DurableOrchestrationTrigger(name = "taskOrchestrationContext") TaskOrchestrationContext ctx) {

    List<String> urls = List.of(
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps"
    );

    // Fan out: run fetching tasks in parallel
    List<Task<String>> parallelTasks = urls.stream()
        .map(url -> ctx.callActivity("FetchTitle", url, String.class))
        .collect(Collectors.toList());

    // Fan in: wait for all parallel tasks to complete
    List<String> results = ctx.allOf(parallelTasks).await();

    // Return fetched titles as a formatted string
    return String.join("; ", results);
}

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Die Titelabrufaktivitäten werden mithilfe einer dynamischen Aufgabenliste nachverfolgt. Die Zeile yield context.df.Task.all(parallelTasks) wartet darauf, dass alle aufgerufenen Aktivitäten, die gleichzeitig ausgeführt werden, abgeschlossen sind. Wenn alles abgeschlossen ist, werden alle Ausgaben zu einer Zeichenfolge formatiert und aggregiert.

df.app.orchestration('fetchOrchestration', function* (context) {
    context.log("Fetching data.");

    const urls = [
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
        "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
        "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
        "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps",
    ];

    // Fan out: run fetching tasks in parallel
    const parallelTasks = urls.map(url => context.df.callActivity(activityName, url));

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

    // Return fetched titles as a formatted string
    return results.join("; ");
});

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Die Titelabrufaktivitäten werden mithilfe einer dynamischen Aufgabenliste nachverfolgt. Die Zeile Wait-ActivityFunction -Task $parallelTasks wartet darauf, dass alle aufgerufenen Aktivitäten, die gleichzeitig ausgeführt werden, abgeschlossen sind. Wenn alles abgeschlossen ist, werden alle Ausgaben zu einer Zeichenfolge formatiert und aggregiert.

param($Context)

$urls = @(
    "https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview",
    "https://learn.microsoft.com/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler",
    "https://learn.microsoft.com/azure/azure-functions/functions-scenarios",
    "https://learn.microsoft.com/azure/azure-functions/functions-create-ai-enabled-apps"
)

# Fan out: run fetching tasks in parallel
$parallelTasks = @()
foreach ($url in $urls) {
    $parallelTasks += Invoke-DurableActivity -FunctionName 'FetchTitle' -Input $url -NoWait
}

# Fan in: wait for all parallel tasks to complete
$results = Wait-ActivityFunction -Task $parallelTasks

# Return fetched titles as a formatted string
$output = $results -join "; "
$output

Hier können Sie das vollständige Vorlagenprojekt überprüfen.

Nachdem du deine Funktionen lokal überprüft hast, ist es Zeit, sie auf Azure zu deployen.

In Azure bereitstellen

Führe diesen Befehl aus dem Root-Projektordner aus, um dein Codeprojekt in Azure in der Funktions-App zu deployen:

azd deploy

Der Befehl azd deploy packt deinen Code und stellt ihn für die während der Bereitstellung erstellte Function App bereit. Nachdem der Befehl abgeschlossen ist, startet und läuft die App im bereitgestellten Paket.

Aufrufen der Funktion für Azure

Sie können jetzt Ihren Orchestrierungsendpunkt in Azure aufrufen, indem Sie eine HTTP-Anforderung an seine URL senden. Wenn Ihre Funktionen in Azure ausgeführt werden, wird eine Zugriffsschlüsselautorisierung erzwungen, und Sie müssen einen Funktionszugriffsschlüssel mit Ihrer Anfrage bereitstellen.

Sie können die Kerntools verwenden, um den URL-Endpunkt des HTTP-Triggers abzurufen, der die Orchestrierung in Azure startet.

  1. Führen Sie in Ihrem lokalen Terminal oder in der Eingabeaufforderung diese Befehle aus, um die Werte für die URL-Endpunkte zu erhalten:

    APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
func azure functionapp list-functions $APP_NAME --show-keys

    Der azd env get-value-Befehl ruft ihren Funktions-App-Namen aus der lokalen Umgebung ab. Wenn Sie die --show-keys Option mit func azure functionapp list-functionsverwenden, enthält der zurückgegebene Aufruf-URL: Wert für jeden Endpunkt alle erforderlichen Zugriffstasten auf Funktionsebene.

  2. Verwenden Sie einen Browser oder ein HTTP-Testtool, um eine GET-Anfrage an den HTTP-Start-Endpunkt zu stellen, um die Orchestrierung in Ihrer Funktions-App in Azure zu starten.

Code erneut bereitstellen

Führe azd deploy so oft aus, wie nötig, um Codeupdates für deine Funktions-App bereitzustellen. Wenn du die Azure-Ressourcen aktualisieren musst, führe es erneut ausazd provision.

Note

Das neueste Bereitstellungspaket überschreibt immer bereitgestellte Codedateien.

Ihre ersten Antworten auf azd Prompts und alle von azd generierten Umgebungsvariablen werden lokal in Ihrer benannten Umgebung gespeichert. Verwenden Sie den azd env get-values Befehl, um alle Variablen in Ihrer Umgebung zu überprüfen, die Sie beim Erstellen von Azure-Ressourcen verwendet haben.

Bereinigen von Ressourcen

Wenn Sie mit der Arbeit mit Ihrer Funktions-App und verwandten Ressourcen fertig sind, verwenden Sie diesen Befehl, um die Funktions-App und die zugehörigen Ressourcen aus Azure zu löschen und weitere Kosten zu vermeiden:

azd down --no-prompt

Note

Die --no-prompt-Option weist azd an, Ihre Ressourcengruppe ohne Bestätigung von Ihnen zu löschen.

Dieser Befehl wirkt sich nicht auf Ihr lokales Codeprojekt aus.

Verwandte Inhalte

  • Last updated on