Avvio rapido: Creare e distribuire funzioni in Funzioni di Azure usando Azure Developer CLI
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.
Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
- 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
- Uno strumento di test HTTP sicuro per l'invio di richieste con payload JSON agli endpoint di funzione. Questo articolo usa
curl
.
È 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. Inazd
, 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. Inazd
, 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. Inazd
, 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. Inazd
, 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. Inazd
, 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. Inazd
, 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.
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
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: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'endpointhttppost
: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 progettotest.http
.Al termine, premere CTRL+C nella finestra del terminale per arrestare il processo host
func.exe
.
- Eseguire
deactivate
per arrestare l'ambiente virtuale.
È possibile esaminare il codice che definisce i due endpoint della funzione trigger HTTP:
[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}!")
È 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.
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 daazd
.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.
È 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:
Il comando
azd env get-value
ottiene il nome dell'app per le funzioni dall'ambiente locale, necessario per la distribuzione, usandofunc azure functionapp publish
. Al termine della pubblicazione, vengono visualizzati i collegamenti agli endpoint del trigger HTTP 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 daazd
.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.
È 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:
$APP_NAME = azd env get-value AZURE_FUNCTION_NAME 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
confunc 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.
È 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.
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.