Avvio rapido: Creare una funzione in Azure dalla riga di comando

In questo articolo si usano gli strumenti da riga di comando locali per creare una funzione che risponde alle richieste HTTP. Dopo aver verificato il codice in locale, distribuirlo in un piano di hosting Flex Consumption serverless in Funzioni di Azure.

Il completamento di questa guida di avvio rapido comporta un piccolo addebito di pochi centesimi di dollaro o meno nell'account Azure.

Assicurarsi di selezionare il linguaggio di sviluppo preferito nella parte superiore dell'articolo.

Prerequisites

Un account Azure con una sottoscrizione attiva. Creare un account gratuito.

.NET 8.0 SDK
Emulatore di archiviazione di Azurite

Kit per sviluppatori Java 17
- Se si usa un'altra versione supportata di Java, è necessario aggiornare il file di pom.xml del progetto.
- La JAVA_HOME variabile di ambiente deve essere impostata sul percorso di installazione della versione corretta di Java Development Kit (JDK).
Apache Maven 3.8.x

Node.js 20

Go
Rust

Go, versione più recente consigliata. Usare il comando go version per controllare la versione in uso.

Interfaccia della riga di comando di Azure
Il jq processore JSON della riga di comando, usato per analizzare l'output JSON ed è disponibile anche in Azure Cloud Shell.

Installare gli strumenti di base per Funzioni di Azure

Il modo consigliato per installare Core Tools dipende dal sistema operativo del computer di sviluppo locale.

La procedura seguente usa un programma di installazione di Windows per installare Core Tools v4.x. Per ulteriori informazioni su altri programmi di installazione basati su pacchetti, consultare il file leggimi Core Tools.

Scaricare ed eseguire il programma di installazione di Core Tools, in base alla versione di Windows:

v4.x - Windows a 64 bit (scelta consigliata. Il debug di Visual Studio Code richiede 64 bit).
v4.x - Windows 32 bit

Se in precedenza è stato usato Windows Installer (MSI) per installare Core Tools in Windows, è necessario disinstallare la versione precedente da Installazione applicazioni prima di installare la versione più recente.

I passaggi seguenti usano Homebrew per installare gli strumenti di base su macOS.

Installare Homebrew, se non è già installato.

Installare il pacchetto degli strumenti di base:

brew tap azure/functions
brew install azure-functions-core-tools@4
# if upgrading on a machine that has 2.x or 3.x installed:
brew link --overwrite azure-functions-core-tools@4

La procedura seguente usa APT per installare gli strumenti di base nella distribuzione Ubuntu/Debian Linux. Per altre distribuzioni Linux, vedere il file leggimi degli strumenti di base.

Installare la chiave GPG del repository di pacchetti Microsoft per convalidare l'integrità del pacchetto:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg

Configurare l'elenco di origine APT prima di eseguire un aggiornamento APT.

Ubuntu

sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-$(lsb_release -cs 2>/dev/null)-prod $(lsb_release -cs 2>/dev/null) main" > /etc/apt/sources.list.d/dotnetdev.list'

Debian

sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/debian/$(lsb_release -rs 2>/dev/null | cut -d'.' -f 1)/prod $(lsb_release -cs 2>/dev/null) main" > /etc/apt/sources.list.d/dotnetdev.list'

Verificare il file /etc/apt/sources.list.d/dotnetdev.list per una delle stringhe di versione Linux appropriate nella tabella seguente:

Distribuzione di Linux	Version
Debian 12	`bookworm`
Debian 11	`bullseye`
Debian 10	`buster`
Debian 9	`stretch`
Ubuntu 24.04	`noble`
Ubuntu 22.04	`jammy`
Ubuntu 20.04	`focal`
Ubuntu 19.04	`disco`
Ubuntu 18.10	`cosmic`
Ubuntu 18.04	`bionic`
Ubuntu 17.04	`zesty`
Ubuntu 16.04/Linux Mint 18	`xenial`

Avviare l'aggiornamento dell'origine APT:
```
sudo apt-get update
```

Installare il pacchetto degli strumenti di base:

sudo apt-get install azure-functions-core-tools-4

Creare e attivare un ambiente virtuale

In una cartella appropriata eseguire i comandi seguenti per creare e attivare un ambiente virtuale denominato .venv. Assicurarsi di usare una delle versioni di Python supportate da Funzioni di Azure.

python -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

.venv\scripts\activate

py -m venv .venv

.venv\scripts\activate

È possibile eseguire tutti i comandi successivi in questo ambiente virtuale attivato.

Creare un progetto e una funzione di codice locale

In Funzioni di Azure il progetto di codice è un'app che contiene una o più singole funzioni che rispondono a un trigger specifico. Tutte le funzioni di un progetto condividono le stesse configurazioni e vengono distribuite come unità in Azure. In questa sezione viene creato un progetto di codice contenente una singola funzione.

In un terminale o nel prompt dei comandi eseguire questo func init comando per creare un progetto di app per le funzioni nella cartella corrente:
```
func init --worker-runtime dotnet-isolated 
```

In un terminale o nel prompt dei comandi eseguire questo func init comando per creare un progetto di app per le funzioni nella cartella corrente:
```
func init --worker-runtime node --language javascript 
```

In un terminale o nel prompt dei comandi eseguire questo func init comando per creare un progetto di app per le funzioni nella cartella corrente:
```
func init --worker-runtime powershell 
```

In un terminale o nel prompt dei comandi eseguire questo func init comando per creare un progetto di app per le funzioni nella cartella corrente:
```
func init --worker-runtime python 
```

In un terminale o nel prompt dei comandi eseguire questo func init comando per creare un progetto di app per le funzioni nella cartella corrente:
```
func init --worker-runtime node --language typescript 
```

In un terminale o nel prompt dei comandi eseguire questo func init comando per creare un progetto di app per le funzioni nella cartella corrente:
```
func init --worker-runtime custom 
```

In una cartella vuota eseguire questo mvn comando per generare il progetto di codice da un archetipo Maven di Funzioni di Azure:

mvn archetype:generate -DarchetypeGroupId=com.microsoft.azure -DarchetypeArtifactId=azure-functions-archetype -DjavaVersion=17

mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DjavaVersion=17"

mvn archetype:generate "-DarchetypeGroupId=com.microsoft.azure" "-DarchetypeArtifactId=azure-functions-archetype" "-DjavaVersion=17"

Important

Usare -DjavaVersion=11 per eseguire le funzioni in Java 11. Per altre informazioni, vedere Versioni java.
Imposta la variabile di ambiente JAVA_HOME sul percorso di installazione della versione corretta del JDK per completare questo articolo.

Maven chiede i valori necessari per completare la generazione del progetto nella distribuzione.
Specificare i valori seguenti quando richiesto:

Prompt	Value	Description
groupId	`com.fabrikam`	Un valore che identifica in modo univoco il progetto tra tutti gli altri, seguendo le regole di denominazione dei pacchetti per Java.
artifactId	`fabrikam-functions`	Un valore che corrisponde al nome del jar, senza un numero di versione.
version	`1.0-SNAPSHOT`	Scegliere il valore predefinito.
package	`com.fabrikam`	Un valore che corrisponde al pacchetto Java per il codice della funzione generato. Usare quello predefinito.

Digitare Y o premere INVIO per confermare.

Maven crea i file di progetto in una nuova cartella con un nome artifactId, che in questo esempio è fabrikam-functions.
Passare alla cartella del progetto:
```
cd fabrikam-functions
```
È possibile esaminare il codice generato dal modello per la nuova funzione trigger HTTP in Function.java nella directory del progetto \src\main\java\com\fabrikam.

Usare questo func new comando per aggiungere una funzione al progetto:
```
func new --name HttpExample --template "HTTP trigger" --authlevel "function"
```
Al progetto viene aggiunto un nuovo file di codice. In questo caso, l'argomento --name è il nome univoco della funzione (HttpExample) e l'argomento --template specifica un trigger HTTP.

La cartella radice del progetto contiene vari file per il progetto, inclusi i file di configurazione denominati local.settings.json e host.json. Poiché local.settings.json può contenere segreti scaricati da Azure, per impostazione predefinita il file viene escluso dal controllo del codice sorgente nel file con estensione gitignore.

Creare e compilare la funzione

Il file function.json nella cartella HttpExample dichiara una funzione trigger HTTP. Per completare la funzione, aggiungere un gestore e compilarlo in un eseguibile.

Go
Rust

Premere CTRL+N (Cmd + N in macOS) per creare un nuovo file. Salvarlo come handler.go nella radice dell'app per le funzioni (nella stessa cartella di host.json).

In handler.go, aggiungere il codice seguente e salvare il file. Questo è il gestore personalizzato Go.

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    message := "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.\n"
    name := r.URL.Query().Get("name")
    if name != "" {
        message = fmt.Sprintf("Hello, %s. This HTTP triggered function executed successfully.\n", name)
    }
    fmt.Fprint(w, message)
}

func main() {
    listenAddr := ":8080"
    if val, ok := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT"); ok {
        listenAddr = ":" + val
    }
    http.HandleFunc("/api/HttpExample", helloHandler)
    log.Printf("About to listen on %s. Go to https://127.0.0.1%s/", listenAddr, listenAddr)
    log.Fatal(http.ListenAndServe(listenAddr, nil))
}

Premere CTRL+ MAIUSC + ` o selezionare Nuovo terminale dal menu Terminale per aprire un nuovo terminale integrato in VS Code.
Compilare il gestore personalizzato usando il comando seguente. Un file eseguibile denominato handler (handler.exe in Windows) viene restituito nella cartella radice dell'app per le funzioni.
```
go build handler.go
```

Premere CTRL+ MAIUSC + ` o selezionare Nuovo terminale dal menu Terminale per aprire un nuovo terminale integrato in VS Code.
Nella radice dell'app per le funzioni (la stessa cartella di host.json), inizializzare un progetto Rust denominato handler.
```
cargo init --name handler
```
In Cargo.toml aggiungere le dipendenze seguenti necessarie per completare questa guida introduttiva. Nell'esempio viene usato il framework del server Web warp.
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

In src/main.rs, aggiungere il codice seguente e salvare il file. Questo è il gestore personalizzato di Rust.

use std::collections::HashMap;
use std::env;
use std::net::Ipv4Addr;
use warp::{http::Response, Filter};

#[tokio::main]
async fn main() {
    let example1 = warp::get()
        .and(warp::path("api"))
        .and(warp::path("HttpExample"))
        .and(warp::query::<HashMap<String, String>>())
        .map(|p: HashMap<String, String>| match p.get("name") {
            Some(name) => Response::builder().body(format!("Hello, {}. This HTTP triggered function executed successfully.", name)),
            None => Response::builder().body(String::from("This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.")),
        });

    let port_key = "FUNCTIONS_CUSTOMHANDLER_PORT";
    let port: u16 = match env::var(port_key) {
        Ok(val) => val.parse().expect("Custom Handler port is not a number!"),
        Err(_) => 3000,
    };

    warp::serve(example1).run((Ipv4Addr::LOCALHOST, port)).await
}

Compilare un file binario per il gestore personalizzato. Un file eseguibile denominato handler (handler.exe in Windows) viene restituito nella cartella radice dell'app per le funzioni.
```
cargo build --release
cp target/release/handler .
```

Configurare l'app per le funzioni

L'host della funzione deve essere configurato per eseguire il file binario del gestore personalizzato all'avvio.

Aprire host.json.
Nella sezione customHandler.description impostare il valore di defaultExecutablePath su handler (in Windows, impostarlo su handler.exe).
Nella sezione customHandler aggiungere una proprietà denominata enableForwardingHttpRequest e impostarne il valore su true. Per le funzioni costituite solo da un trigger HTTP, questa impostazione semplifica la programmazione consentendo di usare una richiesta HTTP tipica anziché il payload della richiesta del gestore personalizzato.

Verificare che la sezione customHandler abbia un aspetto simile a questo esempio. Salva il file.

"customHandler": {
  "description": {
    "defaultExecutablePath": "handler",
    "workingDirectory": "",
    "arguments": []
  },
  "enableForwardingHttpRequest": true
}

L'app per le funzioni è configurata per avviare l'eseguibile del gestore personalizzato.

Eseguire la funzione in locale

Verificare la nuova funzione eseguendo il progetto in locale e chiamando l'endpoint della funzione.

Usa questo comando per avviare l'host runtime di Azure Functions locale nella directory principale della cartella del progetto:

func start

npm install
npm start

mvn clean package  
mvn azure-functions:run

Verso la fine dell'output vengono visualizzate le righe seguenti:

 ...

 Now listening on: http://0.0.0.0:7071
 Application started. Press Ctrl+C to shut down.

 Http Functions:

         HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
 ...

Copiare l'URL della funzione HttpExample da questo output e incollarlo in un browser, quindi andare all'URL della funzione. Si dovrebbe ricevere una risposta di esito positivo con un messaggio "hello world".

Note

Poiché l'autorizzazione della chiave di accesso non viene applicata durante l'esecuzione in locale, l'URL della funzione restituito non include il valore della chiave di accesso e non è necessario per chiamare la funzione.
Dopo aver terminato, usa CTRL+C e y per arrestare l'host delle funzioni.

Creare le risorse di Azure di supporto per la funzione

Prima di poter distribuire il codice della funzione in Azure, è necessario creare queste risorse:

Un gruppo di risorse, ovvero un contenitore logico di risorse correlate.
Un account di archiviazione predefinito, usato dall'host funzioni per mantenere lo stato e altre informazioni sulle funzioni.
Identità gestita assegnata dall'utente, usata dall'host funzioni per connettersi all'account di archiviazione predefinito.
Un'app per le funzioni, che fornisce l'ambiente per l'esecuzione del codice della funzione. Un'app per le funzioni si collega al progetto di funzione locale e consente di raggruppare le funzioni come un'unità logica per semplificare la gestione, la distribuzione e la condivisione di risorse.

Usare i comandi dell'interfaccia della riga di comando di Azure in questi passaggi per creare le risorse necessarie.

Se non è già stato fatto, accedere ad Azure:
```
az login
```
Il comando az login consente di accedere all'account Azure. Ignorare questo passaggio durante l'esecuzione in Azure Cloud Shell.
Se non è già stato fatto, usare questo az extension add comando per installare l'estensione Application Insights:
```
az extension add --name application-insights
```
Usare questo comando az group create per creare un gruppo di risorse denominato AzureFunctionsQuickstart-rg nell'area scelta:
```
az group create --name "AzureFunctionsQuickstart-rg" --location "<REGION>"
```
In questo esempio sostituire <REGION> con un'area vicina che supporta il piano Flex Consumption. Usare il comando az functionapp list-flexconsumption-locations per visualizzare l'elenco delle aree attualmente supportate.
Usare questo comando az storage account create per creare un account di archiviazione per utilizzo generico nel gruppo di risorse e nell'area:
```
az storage account create --name <STORAGE_NAME> --location "<REGION>" --resource-group "AzureFunctionsQuickstart-rg" \
--sku "Standard_LRS" --allow-blob-public-access false --allow-shared-key-access false
```
In questo esempio sostituire <STORAGE_NAME> con un nome appropriato per l'utente e univoco in Archiviazione di Azure. I nomi devono contenere da tre a 24 caratteri costituiti esclusivamente da numeri e lettere in minuscolo. Standard_LRS specifica un account per utilizzo generico, che è supportato da Funzioni. È possibile accedere a questo nuovo account solo usando le identità autenticate da Microsoft Entra a cui sono state concesse autorizzazioni per risorse specifiche.
Usare questo script per creare un'identità gestita assegnata dall'utente, analizzare le proprietà JSON restituite dell'oggetto usando jqe concedere Storage Blob Data Owner le autorizzazioni nell'account di archiviazione predefinito:
```
output=$(az identity create --name "func-host-storage-user" --resource-group "AzureFunctionsQuickstart-rg" --location <REGION> \
--query "{userId:id, principalId: principalId, clientId: clientId}" -o json)

userId=$(echo $output | jq -r '.userId')
principalId=$(echo $output | jq -r '.principalId')
clientId=$(echo $output | jq -r '.clientId')

storageId=$(az storage account show --resource-group "AzureFunctionsQuickstart-rg" --name <STORAGE_NAME> --query 'id' -o tsv)
az role assignment create --assignee-object-id $principalId --assignee-principal-type ServicePrincipal \
--role "Storage Blob Data Owner" --scope $storageId
```
Se non si ha l'utilità jq nella shell Bash locale, è disponibile in Azure Cloud Shell. In questo esempio sostituire <STORAGE_NAME> e <REGION> rispettivamente con il nome e l'area dell'account di archiviazione predefiniti.

Il comando az identity create crea un'identità denominata func-host-storage-user. L'oggetto restituito principalId viene usato per assegnare le autorizzazioni a questa nuova identità nell'account di archiviazione predefinito utilizzando il comando az role assignment create. Il az storage account show comando viene usato per ottenere l'ID dell'account di archiviazione.

Usare questo comando az functionapp create per creare l'app per le funzioni in Azure:

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime dotnet-isolated --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime java --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime node --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime python --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime python --runtime-version <LANGUAGE_VERSION> --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

az functionapp create --resource-group "AzureFunctionsQuickstart-rg" --name <APP_NAME> --flexconsumption-location <REGION> \
--runtime other --storage-account <STORAGE_NAME> \
--deployment-storage-auth-type UserAssignedIdentity --deployment-storage-auth-value "func-host-storage-user"

In questo esempio sostituire questi segnaposto con i valori appropriati:

<APP_NAME>: un nome univoco globale appropriato per te. <APP_NAME> è anche il dominio DNS predefinito per l'app per le funzioni.
<STORAGE_NAME>: nome dell'account usato nel passaggio precedente.
<REGION>: la tua regione corrente.
<LANGUAGE_VERSION>: usare la stessa versione dello stack di linguaggio supportata verificata in locale, se applicabile.

Questo comando crea un'app per le funzioni che esegue il runtime del linguaggio specificato su Linux nel Piano a consumo Flex, che è gratuito per la quantità di utilizzo prevista in questo argomento. Il comando crea anche un'istanza di Azure Application Insights associata nello stesso gruppo di risorse, con cui è possibile usare per monitorare le esecuzioni dell'app per le funzioni e visualizzare i log. Per altre informazioni, vedere Monitorare Funzioni di Azure. L'istanza non comporta costi finché non viene attivata.

Usare questo script per aggiungere l'identità gestita assegnata dall'utente al ruolo di pubblicazione metriche di monitoraggio nell'istanza di Application Insights:
```
appInsights=$(az monitor app-insights component show --resource-group "AzureFunctionsQuickstart-rg" \
    --app <APP_NAME> --query "id" --output tsv)
principalId=$(az identity show --name "func-host-storage-user" --resource-group "AzureFunctionsQuickstart-rg" \
    --query principalId -o tsv)
az role assignment create --role "Monitoring Metrics Publisher" --assignee $principalId --scope $appInsights
```
In questo esempio sostituire <APP_NAME> con il nome dell'app per le funzioni. Il comando az role assignment create aggiunge l'utente al ruolo. L'ID risorsa dell'istanza di Application Insights e l'ID principale dell'utente si ottengono usando rispettivamente i comandi az monitor app-insights component show e az identity show.

Aggiornare le impostazioni dell'applicazione

Per consentire all'host di Funzioni di connettersi all'account di archiviazione predefinito usando segreti condivisi, sostituire l'impostazione della AzureWebJobsStorage stringa di connessione con diverse impostazioni precedute da AzureWebJobsStorage__. Queste impostazioni definiscono un'impostazione complessa usata dall'app per connettersi all'archiviazione e ad Application Insights con un'identità gestita assegnata dall'utente.

Usare questo script per ottenere l'ID client dell'identità gestita assegnata dall'utente e lo usa per definire le connessioni di identità gestite sia all'archiviazione che ad Application Insights:

clientId=$(az identity show --name func-host-storage-user \
    --resource-group AzureFunctionsQuickstart-rg --query 'clientId' -o tsv)
az functionapp config appsettings set --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" \
    --settings AzureWebJobsStorage__accountName=<STORAGE_NAME> \
    AzureWebJobsStorage__credential=managedidentity AzureWebJobsStorage__clientId=$clientId \
    APPLICATIONINSIGHTS_AUTHENTICATION_STRING="ClientId=$clientId;Authorization=AAD"

In questo script sostituire <APP_NAME> e <STORAGE_NAME> con i nomi rispettivamente dell'app per le funzioni e dell'account di archiviazione.

Eseguire il comando az functionapp config appsettings delete per rimuovere l'impostazione della stringa di connessione esistente AzureWebJobsStorage , che contiene una chiave privata condivisa:
```
az functionapp config appsettings delete --name <APP_NAME> --resource-group "AzureFunctionsQuickstart-rg" --setting-names AzureWebJobsStorage
```
In questo esempio sostituire <APP_NAME> con i nomi dell'app per le funzioni.

A questo punto, l'host delle funzioni può connettersi all'account di archiviazione in modo sicuro utilizzando le identità gestite anziché i segreti condivisi. È ora possibile distribuire il codice del progetto nelle risorse di Azure.

Distribuire il progetto di funzione in Azure

Dopo aver creato l'app per le funzioni in Azure, è ora possibile distribuire il progetto di funzioni locale usando il comando func azure functionapp publish.

Nella cartella del progetto radice eseguire questo comando func azure functionapp publish:

func azure functionapp publish <APP_NAME>

In questo esempio sostituire <APP_NAME> con il nome dell'app. Una distribuzione riuscita mostra risultati simili all'output seguente (troncato per semplicità):

 ...

 Getting site publishing info...
 Creating archive for current directory...
 Performing remote build for functions project.

 ...

 Deployment successful.
 Remote build succeeded!
 Syncing triggers...
 Functions in msdocs-azurefunctions-qs:
     HttpExample - [httpTrigger]
         Invoke url: https://msdocs-azurefunctions-qs.azurewebsites.net/api/httpexample

Nel terminale locale o nel prompt dei comandi eseguire questo comando per ottenere il valore dell'endpoint URL, inclusa la chiave di accesso:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
In questo esempio sostituire <APP_NAME> di nuovo con il nome dell'app.
Copiare l'URL e la chiave dell'endpoint restituiti, che si usa per richiamare l'endpoint della funzione.

Aggiornare il file pom.xml

Dopo aver creato correttamente l'app per le funzioni in Azure, aggiornare il file pom.xml in modo che Maven possa essere distribuito nella nuova app. In caso contrario, Maven crea un nuovo set di risorse di Azure durante la distribuzione.

In Azure Cloud Shell usare questo az functionapp show comando per ottenere l'URL del contenitore di distribuzione e l'ID della nuova identità gestita assegnata dall'utente:

az functionapp show --name <APP_NAME> --resource-group AzureFunctionsQuickstart-rg  \
    --query "{userAssignedIdentityResourceId: properties.functionAppConfig.deployment.storage.authentication.userAssignedIdentityResourceId, \
    containerUrl: properties.functionAppConfig.deployment.storage.value}"

In questo esempio sostituire <APP_NAME> con i nomi dell'app per le funzioni.

Nella directory radice del progetto aprire il file pom.xml in un editor di testo, individuare l'elemento properties e aggiornare questi valori di proprietà specifici:

Nome della proprietà	Value
`java.version`	Usare la stessa versione dello stack di linguaggio supportata verificata in locale, ad esempio `17`.
`azure.functions.maven.plugin.version`	`1.37.1`
`azure.functions.java.library.version`	`3.1.0`
`functionAppName`	Nome dell'app per le funzioni in Azure.

Trovare la configuration sezione di azure-functions-maven-plugin e sostituirla con questo frammento XML:

<configuration>
    <appName>${functionAppName}</appName>
    <resourceGroup>AzureFunctionsQuickstart-rg</resourceGroup>
    <pricingTier>Flex Consumption</pricingTier>
    <region>....</region>
    <runtime>
        <os>linux</os>
        <javaVersion>${java.version}</javaVersion>
    </runtime>
    <deploymentStorageAccount>...</deploymentStorageAccount>
    <deploymentStorageResourceGroup>AzureFunctionsQuickstart-rg</deploymentStorageResourceGroup>
    <deploymentStorageContainer>...</deploymentStorageContainer>
    <storageAuthenticationMethod>UserAssignedIdentity</storageAuthenticationMethod>
    <userAssignedIdentityResourceId>...</userAssignedIdentityResourceId>
    <appSettings>
        <property>
            <name>FUNCTIONS_EXTENSION_VERSION</name>
            <value>~4</value>
        </property>
    </appSettings>
</configuration>

Nel nuovo elemento configuration, apportare queste sostituzioni specifiche dei valori degli ellissi (...):

Configuration	Value
`region`	Codice area dell'app di funzioni esistente, ad esempio `eastus`.
`deploymentStorageAccount`	nome dell'account di archiviazione.
`deploymentStorageContainer`	Nome della condivisione di distribuzione, che si trova dopo il `\` nel valore `containerUrl` ottenuto.
`userAssignedIdentityResourceId`	ID risorsa completo dell'identità gestita ottenuta.

Salvare le modifiche apportate al file pom.xml .

È ora possibile usare Maven per distribuire il progetto di codice nell'app esistente.

Distribuire il progetto di funzione in Azure

Dal prompt dei comandi eseguire questo comando:
```
mvn clean package azure-functions:deploy
```
Al termine della distribuzione, eseguire questo comando Core Tools per ottenere il valore dell'endpoint URL, inclusa la chiave di accesso:
```
func azure functionapp list-functions <APP_NAME> --show-keys
```
In questo esempio sostituire <APP_NAME> di nuovo con il nome dell'app.
Copiare l'URL e la chiave dell'endpoint restituiti, che si usa per richiamare l'endpoint della funzione.

Richiamare la funzione in Azure

Poiché la funzione usa un trigger HTTP e supporta le richieste GET, è possibile richiamarla effettuando una richiesta HTTP all'URL usando la chiave di accesso a livello di funzione. È più semplice eseguire una richiesta GET in un browser.

Incollare l'URL e la chiave di accesso copiati in una barra degli indirizzi del browser.

L'URL dell'endpoint dovrebbe essere simile all'esempio seguente:

https://contoso-app.azurewebsites.net/api/httpexample?code=aabbccdd...

In questo caso, è necessario specificare anche una chiave di accesso nella stringa di query quando si effettua una richiesta GET all'URL dell'endpoint. È consigliabile usare una chiave di accesso per limitare l'accesso da client casuali. Quando si effettua una richiesta POST usando un client HTTP, è invece necessario fornire la chiave di accesso nell'intestazione x-functions-key .

Quando si passa a questo URL, il browser dovrebbe visualizzare un output simile al momento dell'esecuzione della funzione in locale.

Pulire le risorse

Se si continua con il passaggio successivo e si aggiunge un binding di output della coda di Archiviazione di Azure, mantenere tutte le risorse esistenti per poterle riutilizzare.

In caso contrario, usare il comando seguente per eliminare il gruppo di risorse e tutte le relative risorse contenute per evitare di incorrere in costi aggiuntivi.

Interfaccia della riga di comando di Azure
Azure PowerShell

az group delete --name AzureFunctionsQuickstart-rg

Remove-AzResourceGroup -Name AzureFunctionsQuickstart-rg

Passaggi successivi

Connettersi ad Archiviazione code di Azure

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-12-04

Condividi tramite

Avvio rapido: Creare una funzione in Azure dalla riga di comando

Prerequisites

Installare gli strumenti di base per Funzioni di Azure

Creare e attivare un ambiente virtuale

Creare un progetto e una funzione di codice locale

Creare e compilare la funzione

Configurare l'app per le funzioni

Eseguire la funzione in locale

Creare le risorse di Azure di supporto per la funzione

Aggiornare le impostazioni dell'applicazione

Distribuire il progetto di funzione in Azure

Aggiornare il file pom.xml

Distribuire il progetto di funzione in Azure

Richiamare la funzione in Azure

Pulire le risorse

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive