Démarrage rapide : Créer et déployer des fonctions dans Azure Functions avec Azure Developer CLI

Article
10/19/2024

Dans ce guide de démarrage rapide, vous utilisez les outils en ligne de commande Azure Developer pour créer des fonctions qui répondent aux requêtes HTTP. Après avoir testé le code localement, vous le déployez sur une nouvelle application de fonction serverless que vous créez et qui s’exécute dans un plan Consommation flexible dans Azure Functions.

La source du projet utilise Azure Developer CLI (azd) pour simplifier le déploiement de votre code sur Azure. Ce déploiement suit les bonnes pratiques actuelles pour les déploiements Azure Functions sécurisés et scalables.

Par défaut, le plan Consommation flexible suit un modèle de facturation de paiement à l’utilisation, ce qui signifie que votre compte Azure sera débité de quelques centimes d’euro ou moins pour suivre ce guide de démarrage rapide.

Prérequis

Compte Azure avec un abonnement actif. Créez un compte gratuitement.
Azure Developer CLI.
Azure Functions Core Tools.

Java 17 Developer Kit
- Si vous utilisez une autre version prise en charge de Java, vous devez mettre à jour le fichier pom.xml du projet.
- La variable d’environnement JAVA_HOME doit être définie sur l’emplacement d’installation de la version appropriée du kit JDK.
Apache Maven 3.8.x

Node.js 20

Python 3.11.

Un outil de test HTTP sécurisé pour envoyer des requêtes avec des charges utiles JSON à vos points de terminaison de fonction. Cet article utilise curl.

Initialiser le projet

Vous pouvez utiliser la commande azd init pour créer un projet de code Azure Functions local à partir d’un modèle.

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :
```
azd init --template functions-quickstart-dotnet-azd -e flexquickstart-dotnet
```
Cette commande extrait les fichiers projet du dépôt de modèles et initialise le projet dans le dossier actuel. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement est utilisé pour maintenir un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.
Exécutez cette commande pour accéder au dossier de l’application http :
```
cd http
```

Créez un fichier nommé local.settings.json dans le dossier http qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated"
    }
}

Ce fichier est requis lors d’une exécution locale.

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :
```
azd init --template azure-functions-java-flex-consumption-azd -e flexquickstart-java 
```
Cette commande extrait les fichiers projet du dépôt de modèles et initialise le projet dans le dossier actuel. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement est utilisé pour maintenir un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.
Exécutez cette commande pour accéder au dossier de l’application http :
```
cd http
```

Créez un fichier nommé local.settings.json dans le dossier http qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "java"
    }
}

Ce fichier est requis lors d’une exécution locale.

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :
```
azd init --template functions-quickstart-javascript-azd -e flexquickstart-js
```
Cette commande extrait les fichiers projet du dépôt de modèles et initialise le projet dans le dossier racine. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement est utilisé pour maintenir un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

Créez un fichier nommé local.settings.json dans le dossier racine qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "node"
    }
}

Ce fichier est requis lors d’une exécution locale.

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :
```
azd init --template functions-quickstart-powershell-azd -e flexquickstart-ps
```
Cette commande extrait les fichiers projet du dépôt de modèles et initialise le projet dans le dossier racine. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement est utilisé pour maintenir un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.
Exécutez cette commande pour accéder au dossier de l’application src :
```
cd src
```

Créez un fichier nommé local.settings.json dans le dossier src qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "powershell",
        "FUNCTIONS_WORKER_RUNTIME_VERSION": "7.2"
    }
}

Ce fichier est requis lors d’une exécution locale.

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :
```
azd init --template functions-quickstart-typescript-azd -e flexquickstart-ts
```
Cette commande extrait les fichiers projet du dépôt de modèles et initialise le projet dans le dossier racine. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement est utilisé pour maintenir un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

Créez un fichier nommé local.settings.json dans le dossier racine qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "node"
    }
}

Ce fichier est requis lors d’une exécution locale.

Dans votre terminal local ou à l’invite de commandes, exécutez cette commande azd init dans un dossier vide :
```
azd init --template functions-quickstart-python-http-azd -e flexquickstart-py
```
Cette commande extrait les fichiers projet du dépôt de modèles et initialise le projet dans le dossier racine. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement est utilisé pour maintenir un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Il est également utilisé dans le nom du groupe de ressources que vous créez dans Azure.

Créez un fichier nommé local.settings.json dans le dossier racine qui contient ces données JSON :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "python"
    }
}

Ce fichier est requis lors d’une exécution locale.

Créer et activer un environnement virtuel

Dans le dossier racine, exécutez ces commandes pour créer et activer un environnement virtuel nommé .venv :

python3 -m venv .venv
source .venv/bin/activate

Si Python n’a pas installé le package venv sur votre distribution Linux, exécutez la commande suivante :

sudo apt-get install python3-venv

py -m venv .venv
source .venv/scripts/activate

py -m venv .venv
.venv\scripts\activate

Exécuter dans votre environnement local

Exécutez cette commande à partir du dossier de votre application dans un terminal ou à l’invite de commandes :
```
func start
```
```
mvn clean package
mvn azure-functions:run
```
```
npm install
func start  
```
```
npm install
npm start  
```
Lorsque l’hôte Functions démarre dans votre dossier de projet local, il écrit les points de terminaison d’URL de vos fonctions déclenchées par requête HTTP dans la sortie du terminal.
Dans votre navigateur, accédez au point de terminaison httpget, qui devrait ressembler à cette URL :

http://localhost:7071/api/httpget
À partir d’une nouvelle fenêtre d’invite de commandes ou de terminal, exécutez cette commande curl pour envoyer une requête POST avec une charge utile JSON au point de terminaison httppost :
```
curl -i http://localhost:7071/api/httppost -H "Content-Type: text/json" -d @testdata.json
```
```
curl -i http://localhost:7071/api/httppost -H "Content-Type: text/json" -d "@src/functions/testdata.json"
```
Cette commande lit les données de la charge utile JSON à partir du fichier projet testdata.json. Vous trouverez des exemples des deux requêtes HTTP dans le fichier projet test.http.
Lorsque vous avez terminé, appuyez sur Ctrl + C dans la fenêtre du terminal pour arrêter le processus hôte func.exe.

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

Examiner le code (facultatif)

Vous pouvez consulter le code qui définit les deux points de terminaison de fonction de déclencheur HTTP :

httpget
httppost

       [Function("httpget")]
       public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "get")]
         HttpRequest req,
         string name)
       {
           var returnValue = string.IsNullOrEmpty(name)
               ? "Hello, World."
               : $"Hello, {name}.";

           _logger.LogInformation($"C# HTTP trigger function processed a request for {returnValue}.");

           return new OkObjectResult(returnValue);
       }

@FunctionName("httpget")
public HttpResponseMessage run(
        @HttpTrigger(
            name = "req",
            methods = {HttpMethod.GET},
            authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

    // Parse query parameter
    String name = Optional.ofNullable(request.getQueryParameters().get("name")).orElse("World");

    return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
}

const { app } = require('@azure/functions');

app.http('httpget', {
    methods: ['GET'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        const name = request.query.get('name') || await request.text() || 'world';

        return { body: `Hello, ${name}!` };
    }
});

import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

export async function httpGetFunction(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || await request.text() || 'world';

    return { body: `Hello, ${name}!` };
};

app.http('httpget', {
    methods: ['GET'],
    authLevel: 'function',
    handler: httpGetFunction
});

Ce fichier function.json définit la fonction httpget :

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get"
      ],
      "route": "httpget"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

Ce fichier run.ps1 implémente le code de fonction :

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters
$name = $Request.Query.name

$body = "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response."

if ($name) {
    $body = "Hello, $name. This HTTP triggered function executed successfully."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $body
})

@app.route(route="httpget", methods=["GET"])
def http_get(req: func.HttpRequest) -> func.HttpResponse:
    name = req.params.get("name", "World")

    logging.info(f"Processing GET request. Name: {name}")

    return func.HttpResponse(f"Hello, {name}!")

[Function("httppost")]
public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
    [FromBody] Person person)
{
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for url {req.Body}");

    if (string.IsNullOrEmpty(person.Name) | string.IsNullOrEmpty(person.Age.ToString()) | person.Age == 0)
    {
        _logger.LogInformation("C# HTTP POST trigger function processed a request with no name/age provided.");
        return new BadRequestObjectResult("Please provide both name and age in the request body.");
    }

    var returnValue = $"Hello, {person.Name}! You are {person.Age} years old.";
    
    _logger.LogInformation($"C# HTTP POST trigger function processed a request for {person.Name} who is {person.Age} years old.");
    return new OkObjectResult(returnValue);
}

@FunctionName("httppost")
public HttpResponseMessage runPost(
        @HttpTrigger(
            name = "req",
            methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.FUNCTION)
            HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a POST request.");

    // Parse request body
    String name;
    Integer age;
    try {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode jsonNode = mapper.readTree(request.getBody().orElse("{}"));
        name = Optional.ofNullable(jsonNode.get("name")).map(JsonNode::asText).orElse(null);
        age = Optional.ofNullable(jsonNode.get("age")).map(JsonNode::asInt).orElse(null);
        if (name == null || age == null) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                    .body("Please provide both name and age in the request body.").build();
        }
    } catch (Exception e) {
        context.getLogger().severe("Error parsing request body: " + e.getMessage());
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                .body("Error parsing request body").build();
    }

const { app } = require('@azure/functions');

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: async (request, context) => {
        context.log(`Http function processed request for url "${request.url}"`);

        try {
            const person = await request.json();
            const { name, age } = person;

            if (!name || !age) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${name}! You are ${age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
    }
});

import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

interface Person {
    name: string;
    age: number;
}

function isPerson(obj: any): obj is Person {
    return typeof obj === 'object' && obj !== null && 
           typeof obj.name === 'string' && 
           typeof obj.age === 'number';
}

export async function httpPostBodyFunction(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

        try {
            const data: any  = await request.json();
    
            if (!isPerson(data)) {
                return {
                    status: 400,
                    body: 'Please provide both name and age in the request body.'
                };
            }

            return {
                status: 200,
                body: `Hello, ${data.name}! You are ${data.age} years old.`
            };
        } catch (error) {
            return {
                status: 400,
                body: 'Invalid request body. Please provide a valid JSON object with name and age.'
            };
        }
};

app.http('httppost', {
    methods: ['POST'],
    authLevel: 'function',
    handler: httpPostBodyFunction
});

Ce fichier function.json définit la fonction httppost :

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "post"
      ],
      "route": "httppost"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

Ce fichier run.ps1 implémente le code de fonction :

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with the body of the request.
$name = $Request.Body.name
$age = $Request.Body.age
$status = [HttpStatusCode]::OK

$body = "This HTTP triggered function executed successfully. Pass a name in the request body for a personalized response."

if ( -not ($name -and $age)){
    $body = "Please provide both 'name' and 'age' in the request body."
    $status = [HttpStatusCode]::BadRequest
}
else {
    <# Action when all if and elseif conditions are false #>
    $body = "Hello, ${name}! You are ${age} years old."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

@app.route(route="httppost", methods=["POST"])
def http_post(req: func.HttpRequest) -> func.HttpResponse:
    try:
        req_body = req.get_json()
        name = req_body.get('name')
        age = req_body.get('age')
        
        logging.info(f"Processing POST request. Name: {name}")

        if name and isinstance(name, str) and age and isinstance(age, int):
            return func.HttpResponse(f"Hello, {name}! You are {age} years old!")
        else:
            return func.HttpResponse(
                "Please provide both 'name' and 'age' in the request body.",
                status_code=400
            )
    except ValueError:
        return func.HttpResponse(
            "Invalid JSON in request body",
            status_code=400
        )

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

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

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

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

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

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

Après avoir vérifié vos fonctions en local, il est temps de les publier sur Azure.

Créer des ressources Azure

Ce projet est configuré pour utiliser la commande azd provision visant à créer une application de fonction dans un plan Consommation flexible, ainsi que d’autres ressources Azure requises.

Remarque

Ce projet comprend un ensemble de fichiers Bicep qu’utilise azd pour créer un déploiement sécurisé dans un plan Consommation flexible qui suit les bonnes pratiques.

Actuellement, les commandes azd up et azd deploy ne sont pas prises en charge pour les applications Java.

Dans le dossier racine du projet, exécutez cette commande pour créer les ressources Azure requises :
```
azd provision
```
Le dossier racine contient le fichier de définition azure.yaml exigé par azd.

Si vous n’êtes pas déjà connecté, vous êtes invité à vous authentifier avec votre compte Azure.

Lorsque vous y êtes invité, fournissez ces paramètres de déploiement requis :

Paramètre	Description
Abonnement Azure	Abonnement dans lequel vos ressources sont créées.
Emplacement Azure	Région Azure dans laquelle créer le groupe de ressources qui contient les nouvelles ressources Azure. Seules sont montrées les régions qui prennent actuellement en charge le plan Consommation flexible.

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

Plan Consommation flexible et application de fonction
Stockage Azure (obligatoire) et Application Insights (recommandé)
Stratégies d’accès et rôles pour votre compte
Connexions de service à service avec des identités managées (au lieu de chaînes de connexion stockées)
Réseau virtuel pour exécuter de façon sécurisée l’application de fonction et les autres ressources Azure

Une fois la commande terminée, vous pouvez déployer le code de votre projet sur cette nouvelle application de fonction dans Azure.

Déployer dans Azure

Vous pouvez utiliser Core Tools pour empaqueter votre code et le déployer sur Azure à partir du dossier de sortie target.

Accédez au dossier d’application équivalent dans le dossier de sortie target :
```
cd http/target/azure-functions/contoso-functions
```
Ce dossier doit avoir un fichier host.json, qui indique qu’il s’agit de la racine de votre application de fonction Java compilée.
Exécutez ces commandes pour déployer votre projet de code Java compilé sur la nouvelle ressource d’application de fonction dans Azure à l’aide de Core Tools :
- bash
- Cmd
```
APP_NAME=$(azd env get-value AZURE_FUNCTION_NAME)
func azure functionapp publish $APP_NAME
```
```
for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
func azure functionapp publish %APP_NAME% 
```
La commande azd env get-value obtient le nom de votre application de fonction à partir de l’environnement local, qui est requis pour le déploiement avec func azure functionapp publish. Une fois la publication terminée, vous voyez des liens vers les points de terminaison de déclencheur HTTP dans Azure.

Déployer dans Azure

Ce projet est configuré pour utiliser la commande azd up visant à déployer ce projet dans une nouvelle application de fonction dans un plan Consommation flexible dans Azure.

Conseil

Ce projet comprend un ensemble de fichiers Bicep qu’utilise azd pour créer un déploiement sécurisé dans un plan Consommation flexible qui suit les bonnes pratiques.

Exécutez cette commande pour qu’azd crée les ressources Azure requises dans Azure et déployer votre projet de code dans la nouvelle application de fonction :
```
azd up
```
Le dossier racine contient le fichier de définition azure.yaml exigé par azd.

Si vous n’êtes pas déjà connecté, vous êtes invité à vous authentifier avec votre compte Azure.

Lorsque vous y êtes invité, fournissez ces paramètres de déploiement requis :

Paramètre	Description
Abonnement Azure	Abonnement dans lequel vos ressources sont créées.
Emplacement Azure	Région Azure dans laquelle créer le groupe de ressources qui contient les nouvelles ressources Azure. Seules sont montrées les régions qui prennent actuellement en charge le plan Consommation flexible.

La commande azd up utilise votre réponse à ces invites avec les fichiers de configuration Bicep pour effectuer ces tâches de déploiement :

Créez et configurez ces ressources Azure requises (équivalentes à azd provision) :
- Plan Consommation flexible et application de fonction
- Stockage Azure (obligatoire) et Application Insights (recommandé)
- Stratégies d’accès et rôles pour votre compte
- Connexions de service à service avec des identités managées (au lieu de chaînes de connexion stockées)
- Réseau virtuel pour exécuter de façon sécurisée l’application de fonction et les autres ressources Azure
Empaquetez et déployez votre code sur le conteneur de déploiement (équivalent à azd deploy). L’application est ensuite démarrée et s’exécute dans le package déployé.

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

Appeler la fonction sur Azure

Vous pouvez maintenant appeler vos points de terminaison de fonction dans Azure en effectuant des requêtes HTTP à leurs URL à l’aide de votre outil de test HTTP ou à partir du navigateur (pour les requêtes GET). Lorsque vos fonctions s’exécutent dans Azure, l’autorisation par clé d’accès est appliquée et vous devez fournir une clé d’accès de fonction à votre requête.

Vous pouvez utiliser Core Tools pour obtenir les points de terminaison d’URL de vos fonctions s’exécutant dans Azure.

Dans votre terminal local ou à l’invite de commandes, exécutez ces commandes pour obtenir les valeurs des points de terminaison d’URL :

bash
Cmd

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

for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
func azure functionapp list-functions %APP_NAME% --show-keys

PowerShell
Cmd

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

for /f "tokens=*" %i in ('azd env get-value AZURE_FUNCTION_NAME') do set APP_NAME=%i
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. L’utilisation de l’option --show-keys avec func azure functionapp list-functions signifie que la valeur de l’URL d’appel retournée pour chaque point de terminaison inclut une clé d’accès au niveau de la fonction.

Comme précédemment, utilisez votre outil de test HTTP pour valider ces URL dans votre application de fonction s’exécutant dans Azure.

Redéployer votre code

Vous pouvez exécuter la commande azd up autant de fois que nécessaire pour approvisionner vos ressources Azure et déployer des mises à jour de code sur votre application de fonction.

Remarque

Les fichiers de code déployés sont toujours remplacés par le dernier package de déploiement.

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 qui ont été 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, vous pouvez utiliser cette commande pour supprimer l’application de fonction et ses ressources associées d’Azure et éviter d’engendrer de nouveaux frais :

azd down --no-prompt

Remarque

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.