Avvio rapido: Creare e distribuire funzioni in Funzioni di Azure usando Azure Developer CLI

Articolo
10/19/2024

In questa guida introduttiva si usano gli strumenti della riga di comando per sviluppatori di Azure per creare funzioni che rispondono alle richieste HTTP. Dopo aver testato il codice in locale, è possibile distribuirlo in una nuova app per le funzioni serverless creata in un piano a consumo Flex in Funzioni di Azure.

L'origine del progetto usa Azure Developer CLI (azd) per semplificare la distribuzione del codice in Azure. Questa distribuzione segue le procedure consigliate correnti per le distribuzioni di Funzioni di Azure sicure e scalabili.

Importante

Il piano A consumo Flex è attualmente in anteprima.

Per impostazione predefinita, il piano a consumo Flex segue un modello di fatturazione con pagamento in base al consumo, il che significa che completare questa guida introduttiva comporta un costo ridotto di pochi centesimi di USD o inferiore nell'account Azure.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Azure Developer CLI.
Azure Functions Core Tools.

Kit per sviluppatori Java 17
- Se si usa un'altra versione supportata di Java, è necessario aggiornare il file di pom.xml del progetto.
- È necessario impostare la variabile di ambiente JAVA_HOME sul percorso di installazione della versione corretta di JDK.
Apache Maven 3.8.x

Node.js 20

Python 3.11.

Uno strumento di test HTTP sicuro per l'invio di richieste con payload JSON agli endpoint di funzione. Questo articolo usa curl.

Inizializzare il progetto

È possibile usare il comando azd init per creare un progetto di codice di Funzioni di Azure locale da un modello.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-dotnet-azd -e flexquickstart-dotnet
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella corrente. Il flag -e imposta un nome per l'ambiente corrente. In azd, l'ambiente viene usato per mantenere un contesto di distribuzione univoco per l'app ed è possibile definirne più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.
Eseguire questo comando per passare alla cartella dell'app http:
```
cd http
```

Creare un file denominato local.settings.json nella cartella http che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template azure-functions-java-flex-consumption-azd -e flexquickstart-java 
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella corrente. Il flag -e imposta un nome per l'ambiente corrente. In azd, l'ambiente viene usato per mantenere un contesto di distribuzione univoco per l'app ed è possibile definirne più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.
Eseguire questo comando per passare alla cartella dell'app http:
```
cd http
```

Creare un file denominato local.settings.json nella cartella http che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-javascript-azd -e flexquickstart-js
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella principale. Il flag -e imposta un nome per l'ambiente corrente. In azd, l'ambiente viene usato per mantenere un contesto di distribuzione univoco per l'app ed è possibile definirne più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.

Creare un file denominato local.settings.json nella cartella principale che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-powershell-azd -e flexquickstart-ps
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella principale. Il flag -e imposta un nome per l'ambiente corrente. In azd, l'ambiente viene usato per mantenere un contesto di distribuzione univoco per l'app ed è possibile definirne più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.
Eseguire questo comando per passare alla cartella dell'app src:
```
cd src
```

Creare un file denominato local.settings.json nella cartella src che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-typescript-azd -e flexquickstart-ts
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella principale. Il flag -e imposta un nome per l'ambiente corrente. In azd, l'ambiente viene usato per mantenere un contesto di distribuzione univoco per l'app ed è possibile definirne più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.

Creare un file denominato local.settings.json nella cartella principale che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Nel terminale locale o nel prompt dei comandi eseguire questo comando azd init in una cartella vuota:
```
azd init --template functions-quickstart-python-http-azd -e flexquickstart-py
```
Questo comando esegue il pull dei file di progetto dal repository dei modelli e inizializza il progetto nella cartella principale. Il flag -e imposta un nome per l'ambiente corrente. In azd, l'ambiente viene usato per mantenere un contesto di distribuzione univoco per l'app ed è possibile definirne più di uno. Viene usato anche nel nome del gruppo di risorse creato in Azure.

Creare un file denominato local.settings.json nella cartella principale che contiene questi dati JSON:

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

Questo file è necessario durante l'esecuzione locale.

Creare e attivare un ambiente virtuale

Nella cartella principale, eseguire questi comandi per creare e attivare un ambiente virtuale denominato .venv:

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

Se Python non ha installato il pacchetto venv nella distribuzione Linux, eseguire il comando seguente:

sudo apt-get install python3-venv

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

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

Eseguire l'ambiente locale

Eseguire questo comando dalla cartella dell'app in un terminale o nel prompt dei comandi:
```
func start
```
```
mvn clean package
mvn azure-functions:run
```
```
npm install
func start  
```
```
npm install
npm start  
```
Quando l'host Funzioni viene avviato nella cartella del progetto locale, scrive gli endpoint URL delle funzioni attivate da HTTP nell'output del terminale.
Nel browser, passare all'endpoint httpget, che dovrebbe essere simile all'URL seguente:

http://localhost:7071/api/httpget
Da una nuova finestra del terminale o del prompt dei comandi eseguire questo comando curl per inviare una richiesta POST con un payload JSON all'endpoint 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"
```
Questo comando legge i dati del payload JSON dal file di progetto testdata.json. È possibile trovare esempi di entrambe le richieste HTTP nel file di progetto test.http.
Al termine, premere CTRL+C nella finestra del terminale per arrestare il processo host func.exe.

Eseguire deactivate per arrestare l'ambiente virtuale.

Esaminare il codice (facoltativo)

È possibile esaminare il codice che definisce i due endpoint della funzione trigger 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
});

Questo file function.json definisce la funzione httpget:

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

Questo file run.ps1 implementa il codice della funzione:

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

Questo file function.json definisce la funzione httppost:

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

Questo file run.ps1 implementa il codice della funzione:

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
        )

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

È possibile esaminare il progetto di modello completo qui.

Dopo aver verificato le funzioni in locale, è possibile pubblicarle in Azure.

Creare risorse Azure

Questo progetto è configurato per usare il comando azd provision per creare un'app per le funzioni in un piano a consumo Flex, insieme ad altre risorse di Azure necessarie.

Nota

Questo progetto include un set di file Bicep che azd usa per creare una distribuzione sicura in un piano a consumo Flex che segue le procedure consigliate.

I comandi azd up e azd deploy non sono attualmente supportati per le app Java.

Nella cartella radice del progetto eseguire questo comando per creare le risorse di Azure necessarie:
```
azd provision
```
La cartella radice contiene il file di definizione azure.yaml richiesto da azd.

Se non è già stato eseguito l'accesso, viene chiesto di eseguire l'autenticazione con l'account Azure.

Quando richiesto, specificare questi parametri di distribuzione obbligatori:

Parametro	Descrizione
Sottoscrizione di Azure	Sottoscrizione in cui vengono create le risorse.
Località di Azure	Area di Azure in cui creare il gruppo di risorse che contiene le nuove risorse di Azure. Vengono visualizzate solo le aree che attualmente supportano il piano a consumo Flex.

Il comando azd provision usa la risposta a queste richieste con i file di configurazione Bicep per creare e configurare queste risorse di Azure necessarie:

Piano a consumo Flex e app per le funzioni
Archiviazione di Azure (richiesta) e Application Insights (scelta consigliata)
Criteri di accesso e ruoli per l'account
Connessioni da servizio a servizio che usano identità gestite (anziché stringhe di connessione archiviate)
Rete virtuale per eseguire in modo sicuro sia l'app per le funzioni che le altre risorse di Azure

Al termine del comando, è possibile distribuire il codice del progetto in questa nuova app per le funzioni in Azure.

Distribuzione in Azure

È possibile usare gli strumenti core per creare un pacchetto del codice e distribuirlo in Azure dalla cartella di output target.

Passare alla cartella dell'app equivalente nella cartella di output target:
```
cd http/target/azure-functions/contoso-functions
```
Questa cartella deve disporre di un file host.json, che indica che è la radice dell'app per le funzioni Java compilata.
Eseguire questi comandi per distribuire il progetto di codice Java compilato nella nuova risorsa dell'app per le funzioni in Azure usando gli strumenti core:
- 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% 
```
Il comando azd env get-value ottiene il nome dell'app per le funzioni dall'ambiente locale, necessario per la distribuzione, usando func azure functionapp publish. Al termine della pubblicazione, vengono visualizzati i collegamenti agli endpoint del trigger HTTP in Azure.

Distribuzione in Azure

Questo progetto è configurato per l'uso del comando azd up al fine di distribuire questo progetto in una nuova app per le funzioni in un piano a consumo Flex in Azure.

Suggerimento

Questo progetto include un set di file Bicep che azd usa per creare una distribuzione sicura in un piano a consumo Flex che segue le procedure consigliate.

Eseguire questo comando affinché azd possa creare le risorse di Azure necessarie in Azure e distribuire il progetto di codice nella nuova app per le funzioni:
```
azd up
```
La cartella radice contiene il file di definizione azure.yaml richiesto da azd.

Se non è già stato eseguito l'accesso, viene chiesto di eseguire l'autenticazione con l'account Azure.

Quando richiesto, specificare questi parametri di distribuzione obbligatori:

Parametro	Descrizione
Sottoscrizione di Azure	Sottoscrizione in cui vengono create le risorse.
Località di Azure	Area di Azure in cui creare il gruppo di risorse che contiene le nuove risorse di Azure. Vengono visualizzate solo le aree che attualmente supportano il piano a consumo Flex.

Il comando azd up usa la risposta a queste richieste con i file di configurazione Bicep per completare queste attività di distribuzione:

Creare e configurare queste risorse di Azure necessarie (equivalenti a azd provision):
- Piano a consumo Flex e app per le funzioni
- Archiviazione di Azure (richiesta) e Application Insights (scelta consigliata)
- Criteri di accesso e ruoli per l'account
- Connessioni da servizio a servizio che usano identità gestite (anziché stringhe di connessione archiviate)
- Rete virtuale per eseguire in modo sicuro sia l'app per le funzioni che le altre risorse di Azure
Creare un pacchetto e distribuire il codice nel contenitore di distribuzione (equivalente a azd deploy). L'app viene quindi avviata ed eseguita nel pacchetto distribuito.

Al termine del comando, vengono visualizzati i collegamenti alle risorse create.

Richiamare la funzione in Azure

È ora possibile richiamare gli endpoint della funzione in Azure effettuando richieste HTTP negli URL usando lo strumento di test HTTP o dal browser (per le richieste GET). Quando le funzioni vengono eseguite in Azure, viene applicata l'autorizzazione della chiave di accesso ed è necessario fornire una chiave di accesso alla funzione con la richiesta.

È possibile usare gli strumenti core per ottenere gli endpoint URL delle funzioni in esecuzione in Azure.

Nel terminale locale o nel prompt dei comandi, eseguire questi comandi per ottenere i valori dell'endpoint 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

Il comando azd env get-value ottiene il nome dell'app per le funzioni dall'ambiente locale. L'uso dell'opzione --show-keys con func azure functionapp list-functions indica che il valore restituito Invoke URL: per ogni endpoint include una chiave di accesso a livello di funzione.

Come in precedenza, usare lo strumento di test HTTP per convalidare questi URL nell'app per le funzioni in esecuzione in Azure.

Ridistribuire il codice

È possibile eseguire il comando azd up quante volte è necessario effettuare il provisioning delle risorse di Azure e distribuire gli aggiornamenti del codice nell'app per le funzioni.

Nota

I file di codice distribuiti vengono sempre sovrascritti dal pacchetto di distribuzione più recente.

Le risposte iniziali alle richieste di azd e a tutte le variabili di ambiente generate da azd, vengono archiviate localmente nell'ambiente denominato. Usare il comando azd env get-values per esaminare tutte le variabili nell'ambiente usato durante la creazione di risorse di Azure.

Pulire le risorse

Al termine dell'uso dell'app per le funzioni e delle risorse correlate, è possibile usare questo comando per eliminare l'app per le funzioni e le relative risorse da Azure ed evitare di sostenere ulteriori costi:

azd down --no-prompt

Nota

L'opzione --no-prompt indica a azd di eliminare il gruppo di risorse senza conferma.

Questo comando non influisce sul progetto di codice locale.