Démarrage rapide : Créer un flux de travail serverless à l’aide de Durable Functions

Dans ce démarrage rapide, vous utilisez les outils en ligne de commande d'Azure pour créer un flux de travail sans serveur orchestrant plusieurs tâches exécutées en parallèle. Vous créez des ressources dans Azure, vérifiez le code localement, puis le déployez dans une nouvelle application de fonctions serverless fonctionnant dans un plan Flex Consumption dans Azure Functions.

Le projet utilise Azure Developer CLI (azd) pour simplifier le déploiement de votre code sur Azure. Ce déploiement suit les meilleures pratiques actuelles pour les déploiements de Azure Functions sécurisés et évolutifs. Ce guide de démarrage rapide illustre le modèle fan-out/fan-in dans Durable Functions, extension qui orchestre les flux de travail avec état avec une exécution durable. L’exemple utilise le Durable Task Scheduler, un backend entièrement géré pour Durable Functions qui remplace le backend stockage Azure. L’exemple extrait des titres d’article en parallèle : l’orchestration se déploie (fan out) sur plusieurs activités en cours d’exécution simultanément, puis agrège les résultats en mode fan-in.

Par défaut, le plan Flex Consumption suit un modèle de facturation pay-for-you-use, ce qui signifie que le démarrage rapide entraîne un petit coût de quelques cents USD ou moins dans votre compte Azure.

Logiciels requis

Initialiser le projet

Utilisez la commande azd init pour créer un projet de code Durable Functions local à partir d’un modèle.

  1. Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

    Cette commande extrait les fichiers projet du dépôt template et initialise le projet dans un nouveau dossier. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

  2. Changez dans le répertoire du projet puis naviguez vers le dossier de l’application fanoutfanin :

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

  1. Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

    Cette commande extrait les fichiers projet du dépôt template et initialise le projet dans un nouveau dossier. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

  2. Changez dans le répertoire du projet puis naviguez vers le dossier de l’application src :

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

  1. Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

    Cette commande extrait les fichiers projet du dépôt template et initialise le projet dans un nouveau dossier. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

  2. Changez dans le répertoire du projet puis naviguez vers le dossier de l’application src :

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

  1. Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

    Cette commande extrait les fichiers projet du dépôt template et initialise le projet dans un nouveau dossier. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

  2. Accédez au répertoire du projet :

    cd durable-functions-quickstart-java-azd

  1. Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

    Cette commande extrait les fichiers projet du dépôt template et initialise le projet dans un nouveau dossier. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

  2. Changez dans le répertoire du projet puis naviguez vers le dossier de l’application src :

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

  1. Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :

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

    Cette commande extrait les fichiers projet du dépôt template et initialise le projet dans un nouveau dossier. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Le nom de l’environnement est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

  2. Changez dans le répertoire du projet puis naviguez vers le dossier de l’application src :

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

Approvisionner des ressources Azure

Ce projet utilise la azd provision commande pour créer les ressources Azure requises, y compris une nouvelle application de fonctions dans un plan Flex Consumption, un planificateur de tâches durable et un hub de tâches.

Tip

Le projet inclut un ensemble de fichiers Bicep (dossier infra) que azd utilise pour créer un déploiement sécurisé dans un plan de consommation Flex qui suit les meilleures pratiques.

  1. Retournez au dossier racine du projet (le dossier contenant le azure.yaml fichier) :

    cd ..
  1. Assure-toi d’être toujours dans le dossier racine du projet (le dossier qui contient le azure.yaml fichier).

  1. Exécutez cette commande pour authentifier avec votre compte Azure :

    azd auth login

  2. Exécutez cette commande depuis le dossier racine du projet pour azd créer les ressources Azure requises :

    azd provision

    Le dossier racine contient le fichier de définition azure.yaml exigé par azd.

  3. Lorsque vous y êtes invité, fournissez les paramètres de déploiement requis suivants :

    Paramètre Description
    Abonnement Azure Abonnement dans lequel vos ressources sont créées. Si votre compte compte plus d’un locataire, vous devez d’abord choisir votre locataire.
    Emplacement Azure Région Azure où vous allez créer le groupe de ressources qui contient les nouvelles ressources Azure. Seules les régions qui prennent actuellement en charge le plan Flex Consumption sont affichées.
    vnetEnabled S’il faut déployer dans un réseau virtuel. Pour ce démarrage rapide, sélectionnez faux.

    La azd provision commande utilise vos réponses à ces invites avec les fichiers de configuration Bicep pour créer et configurer ces ressources Azure requises :

    • Plan de consommation Flex et application fonctionnelle
    • stockage Azure (obligatoire) et Application Insights (recommandé)
    • Planificateur de tâches durable et hub de tâches
    • Stratégies d’accès et rôles pour votre compte
    • Connexions de service à service à l’aide d’identités managées (au lieu de chaînes de connexion stockées)

    Une fois la commande terminée, vous voyez des liens vers les ressources que vous avez créées.

    Le provisionnement exécute également un script de post-approvisionnement qui génère le fichier local.settings.json dans le dossier de votre application. Ce fichier contient les paramètres de connexion pour le terminau déployé Durable Task Scheduler, dont vous avez besoin pour exécuter le projet localement.

Démarrer Azurite

Pour exécuter le projet localement, l’exécution des fonctions nécessite un émulateur de stockage local. Le "AzureWebJobsStorage": "UseDevelopmentStorage=true" paramètre dans le fichier local.settings.json dirige le runtime pour utiliser Azurite à cette fin.

Dans une nouvelle fenêtre terminale, exécutez cette commande pour lancer Azurite :

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

Faites tourner Azurite dans cette fenêtre de terminal tout en testant localement.

Exécuter dans votre environnement local

  1. Dans votre terminal d’origine, allez dans le fanoutfanin dossier application et lancez l’hôte Fonctions :

    cd fanoutfanin
func start

    Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit les points de terminaison d’URL locaux de vos fonctions déclenchées HTTP dans la sortie du terminal.

    Note

    Étant donné que l’autorisation de clé d’accès n’est pas appliquée lors de l’exécution locale, vous n’avez pas besoin d’une clé d’accès pour appeler votre fonction.

  2. Dans votre navigateur, effectuez une requête GET au point de terminaison qui démarre l’orchestration :

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Cette requête démarre une nouvelle instance d’orchestration. L’orchestration se déploie sur plusieurs activités afin de récupérer les titres des articles Microsoft Learn en parallèle. Une fois les activités terminées, l’orchestration, en mode fan-in, renvoie les titres sous forme de chaîne mise en forme.

  1. Dans votre terminal d’origine, allez dans le src dossier application, créez et activez un environnement virtuel, installez les dépendances, et lancez l’hôte Fonctions :

    cd src

    La manière dont vous créez et activez votre environnement virtuel (nommé .venv) dépend de votre terminal :

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

    Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit les points de terminaison d’URL locaux de vos fonctions déclenchées HTTP dans la sortie du terminal.

    Note

    Étant donné que l’autorisation de clé d’accès n’est pas appliquée lors de l’exécution locale, vous n’avez pas besoin d’une clé d’accès pour appeler votre fonction.

  2. Dans votre navigateur, effectuez une requête GET au point de terminaison de démarrage HTTP :

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

    Cette requête démarre une nouvelle instance d’orchestration. L’orchestration se déploie sur plusieurs activités afin de récupérer les titres des articles Microsoft Learn en parallèle. Une fois les activités terminées, l’orchestration, en mode fan-in, renvoie les titres sous forme de chaîne mise en forme.

  1. Dans votre terminal d’origine, allez dans le src dossier application, installez les dépendances, construisez le projet et lancez l’hôte Fonctions :

    cd src
npm install
npm run build
func start

    Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit les points de terminaison d’URL locaux de vos fonctions déclenchées HTTP dans la sortie du terminal.

    Note

    Étant donné que l’autorisation de clé d’accès n’est pas appliquée lors de l’exécution locale, vous n’avez pas besoin d’une clé d’accès pour appeler votre fonction.

  2. Dans votre navigateur, effectuez une requête GET au point de terminaison de démarrage HTTP :

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

    Cette requête démarre une nouvelle instance d’orchestration. L’orchestration se déploie sur plusieurs activités afin de récupérer les titres des articles Microsoft Learn en parallèle. Une fois les activités terminées, l’orchestration, en mode fan-in, renvoie les titres sous forme de chaîne mise en forme.

  1. Dans votre terminal d’origine, construisez le projet puis lancez l’hôte Fonctions depuis le dossier de sortie de build :

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

    Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit les points de terminaison d’URL locaux de vos fonctions déclenchées HTTP dans la sortie du terminal.

    Note

    Étant donné que l’autorisation de clé d’accès n’est pas appliquée lors de l’exécution locale, vous n’avez pas besoin d’une clé d’accès pour appeler votre fonction.

  2. Dans votre navigateur, effectuez une requête GET au point de terminaison qui démarre l’orchestration :

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Cette requête démarre une nouvelle instance d’orchestration. L’orchestration se déploie sur plusieurs activités afin de récupérer les titres des articles Microsoft Learn en parallèle. Une fois les activités terminées, l’orchestration, en mode fan-in, renvoie les titres sous forme de chaîne mise en forme.

  1. Dans votre terminal d’origine, allez dans le src dossier application, installez les dépendances, et lancez l’hôte Fonctions :

    cd src
npm install
func start

    Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit les points de terminaison d’URL locaux de vos fonctions déclenchées HTTP dans la sortie du terminal.

    Note

    Étant donné que l’autorisation de clé d’accès n’est pas appliquée lors de l’exécution locale, vous n’avez pas besoin d’une clé d’accès pour appeler votre fonction.

  2. Dans votre navigateur, effectuez une requête GET au point de terminaison qui démarre l’orchestration :

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Cette requête démarre une nouvelle instance d’orchestration. L’orchestration se déploie sur plusieurs activités afin de récupérer les titres des articles Microsoft Learn en parallèle. Une fois les activités terminées, l’orchestration, en mode fan-in, renvoie les titres sous forme de chaîne mise en forme.

  1. Dans votre terminal d’origine, allez dans le src dossier application et lancez l’hôte Fonctions :

    cd src
func start

    Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit les points de terminaison d’URL locaux de vos fonctions déclenchées HTTP dans la sortie du terminal.

    Note

    Étant donné que l’autorisation de clé d’accès n’est pas appliquée lors de l’exécution locale, vous n’avez pas besoin d’une clé d’accès pour appeler votre fonction.

  2. Dans votre navigateur, effectuez une requête GET au point de terminaison qui démarre l’orchestration :

    http://localhost:7071/api/FetchOrchestration_HttpStart

    Cette requête démarre une nouvelle instance d’orchestration. L’orchestration se déploie sur plusieurs activités afin de récupérer les titres des articles Microsoft Learn en parallèle. Une fois les activités terminées, l’orchestration, en mode fan-in, renvoie les titres sous forme de chaîne mise en forme.

  1. Le point de terminaison HTTP retourne une réponse JSON avec plusieurs URL. Le statusQueryGetUri endpoint fournit l’état de l’orchestration.

  2. Copiez la valeur et collez-la statusQueryGetUri dans votre navigateur ou outil de test HTTP pour vérifier l’état de l’orchestration. Une fois l’orchestration terminée, les titres des articles extraits apparaissent dans la réponse.

  3. Lorsque vous avez terminé, appuyez sur Ctrl + C dans la fenêtre du terminal pour arrêter le processus hôte func.

  1. Exécutez deactivate pour arrêter l’environnement virtuel.

Examiner le code (facultatif)

Vous pouvez consulter le code qui implémente le modèle fan-out/fan-in :

Les activités d’extraction de titres sont suivies à l’aide d’une liste de tâches dynamique. La ligne await Task.WhenAll(parallelTasks); attend que toutes les activités appelées, qui s’exécutent simultanément, se terminent. Lorsque vous avez terminé, toutes les sorties sont agrégées sous forme de chaîne mise en forme.

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

Vous pouvez consulter le projet de modèle complet ici.

Les activités d’extraction de titres sont suivies à l’aide d’une liste de tâches dynamique. La ligne yield context.task_all(tasks) attend que toutes les activités appelées, qui s’exécutent simultanément, se terminent. Lorsque vous avez terminé, toutes les sorties sont agrégées sous forme de chaîne mise en forme.

    # 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:

Vous pouvez consulter le projet de modèle complet ici.

Les activités d’extraction de titres sont suivies à l’aide d’une liste de tâches dynamique. La ligne yield context.df.Task.all(parallelTasks) attend que toutes les activités appelées, qui s’exécutent simultanément, se terminent. Lorsque vous avez terminé, toutes les sorties sont agrégées sous forme de chaîne mise en forme.

    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

Vous pouvez consulter le projet de modèle complet ici.

Les activités d’extraction de titres sont suivies à l’aide d’une liste de tâches dynamique. La ligne ctx.allOf(parallelTasks).await() attend que toutes les activités appelées, qui s’exécutent simultanément, se terminent. Lorsque vous avez terminé, toutes les sorties sont agrégées sous forme de chaîne mise en forme.

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

Vous pouvez consulter le projet de modèle complet ici.

Les activités d’extraction de titres sont suivies à l’aide d’une liste de tâches dynamique. La ligne yield context.df.Task.all(parallelTasks) attend que toutes les activités appelées, qui s’exécutent simultanément, se terminent. Lorsque vous avez terminé, toutes les sorties sont agrégées sous forme de chaîne mise en forme.

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("; ");
});

Vous pouvez consulter le projet de modèle complet ici.

Les activités d’extraction de titres sont suivies à l’aide d’une liste de tâches dynamique. La ligne Wait-ActivityFunction -Task $parallelTasks attend que toutes les activités appelées, qui s’exécutent simultanément, se terminent. Lorsque vous avez terminé, toutes les sorties sont agrégées sous forme de chaîne mise en forme.

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

Vous pouvez consulter le projet de modèle complet ici.

Après avoir vérifié vos fonctions localement, il est temps de les déployer sur Azure.

Déployer sur Azure

Exécutez cette commande depuis le dossier du projet racine pour déployer votre projet de code dans l’application de fonctions dans Azure :

azd deploy

La azd deploy commande empaquete et déploie votre code dans l’application fonctionnelle créée lors du provisionnement. Après la fin de la commande, l’application démarre et s’exécute dans le package déployé.

Appeler la fonction sur Azure

Vous pouvez maintenant appeler votre point de terminaison d’orchestration dans Azure en effectuant une requête HTTP à son URL. Lorsque vos fonctions s’exécutent dans Azure, l’autorisation de clé d’accès est appliquée et vous devez fournir une clé d’accès de fonction à votre demande.

Vous pouvez utiliser Core Tools pour obtenir le point de terminaison d’URL du déclencheur HTTP qui démarre l’orchestration dans Azure.

  1. Dans votre terminal local ou votre invite de commandes, exécutez ces commandes pour obtenir les valeurs des points de terminaison URL :

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

    La commande azd env get-value obtient le nom de votre application de fonction à partir de l’environnement local. Lorsque vous utilisez l’option --show-keys avec func azure functionapp list-functions, la valeur de l’URL d'appel retournée pour chaque point de terminaison inclut toutes les clés d’accès au niveau de la fonction requises.

  2. Utilisez un navigateur ou un outil de test HTTP pour effectuer une requête GET au point de départ HTTP afin de lancer l’orchestration dans votre application fonctionnelle sous Azure.

Redéployer votre code

Exécutez azd deploy autant de fois que nécessaire pour déployer des mises à jour de code dans votre application de fonctions. Si vous devez mettre à jour les ressources Azure, exécutez à nouveau azd provision.

Note

Le dernier package de déploiement remplace toujours les fichiers de code déployés.

Vos réponses initiales aux invites d’azd et toutes les variables d’environnement générées par azd sont stockées localement dans votre environnement nommé. Utilisez la commande azd env get-values pour passer en revue toutes les variables de votre environnement que vous avez utilisées lors de la création de ressources Azure.

Nettoyer les ressources

Lorsque vous avez terminé d’utiliser votre application de fonction et vos ressources associées, utilisez cette commande pour supprimer l’application de fonction et ses ressources associées d’Azure et éviter d’entraîner d’autres coûts :

azd down --no-prompt

Note

L’option --no-prompt indique à azd de supprimer votre groupe de ressources sans confirmation de votre part.

Cette commande n’affecte pas votre projet de code local.

Contenu connexe

  • Last updated on