Sviluppare Funzioni di Azure con Visual Studio Code

L'estensione Funzioni di Azure per Visual Studio Code consente di sviluppare funzioni in locale e di distribuirle in Azure. Se questa è la prima esperienza con Funzioni di Azure, è consigliabile leggere altre informazioni in Introduzione a Funzioni di Azure.

L'estensione Funzioni di Azure offre questi vantaggi:

• Modificare, compilare ed eseguire funzioni nel computer di sviluppo locale.
• Pubblicare il progetto Funzioni di Azure direttamente in Azure.
• Scrivere le funzioni in vari linguaggi sfruttando i vantaggi di Visual Studio Code.

Prerequisiti

• Visual Studio Code deve essere installato in una delle piattaforme supportate.

• Estensione Funzioni di Azure. È anche possibile installare il pacchetto di estensione Strumenti di Azure, consigliato per l'uso delle risorse di Azure.

• Una sottoscrizione di Azure attiva. Se non si ha ancora un account, è possibile crearne uno dall'estensione in Visual Studio Code.

Questi prerequisiti sono necessari anche per eseguire ed eseguire il debug delle funzioni in locale. Non sono necessari solo per creare o pubblicare progetti in Funzioni di Azure.

• Azure Functions Core Tools, che consente un'esperienza di debug locale integrata. Quando è installata l'estensione Funzioni di Azure, il modo più semplice per installare o aggiornare Core Tools consiste nell'eseguire il comando Azure Functions: Install or Update Azure Functions Core Tools dal riquadro comandi.

Creare un progetto di Funzioni di Azure

L'estensione Funzioni consente di creare il progetto dell'app per le funzioni richiesto contemporaneamente alla creazione della prima funzione. Usare questi passaggi per creare una funzione attivata tramite HTTP in un nuovo progetto. Un trigger HTTP è il modello di trigger di funzione più semplice da illustrare.

1. In Visual Studio Code premere F1 per aprire il riquadro comandi e cercare ed eseguire il comando Azure Functions: Create New Project.... Selezionare la posizione della directory per l'area di lavoro del progetto e quindi scegliere Seleziona.

   È possibile creare una nuova cartella o scegliere una cartella vuota per l'area di lavoro del progetto, ma non scegliere una cartella di progetto che fa già parte di un'area di lavoro.

   È invece possibile eseguire il comando Azure Functions: Create New Containerized Project... per ottenere anche un Dockerfile generato per il progetto.

2. Quando richiesto, selezionare una lingua per il progetto. Se necessario, scegliere una versione specifica della lingua.

3. Selezionare il modello di funzione trigger HTTP oppure selezionare Ignora per il momento per creare un progetto senza una funzione. È sempre possibile aggiungere una funzione al progetto in un secondo momento.

   Suggerimento

   È possibile visualizzare altri modelli selezionando l'opzione Modifica filtro modello e impostando il valore su Core o All.

4. Per il nome della funzione immettere HttpExample, selezionare INVIO e quindi selezionare autorizzazione Funzione.

   Questo livello di autorizzazione richiede di fornire una chiave di funzione quando si chiama l'endpoint della funzione.

5. Nell'elenco a discesa selezionare Aggiungi all'area di lavoro.

6. Nella finestra Consideri attendibili gli autori dei file in questa cartella? selezionare Sì.

Visual Studio Code crea una funzione nel linguaggio scelto e nel modello per una funzione attivata da HTTP.

File di progetto generati

Il modello di progetto crea un progetto nel linguaggio scelto e installa le dipendenze necessarie. Per qualsiasi linguaggio, il nuovo progetto include questi file:

• host.json: consente di configurare l'host di Funzioni. Queste impostazioni si applicano quando si eseguono funzioni in locale e quando vengono eseguite in Azure. Per altre informazioni, vedere il riferimento su host.json.

• local.settings.json: mantiene le impostazioni usate quando si eseguono funzioni localmente. Queste impostazioni vengono usate solo quando si eseguono funzioni in locale. Per maggiori informazioni, vedere File di impostazioni locali.

  Importante

  Poiché il file local.settings.json può contenere segreti, assicurarsi di escludere il file dal controllo del codice sorgente del progetto.

• Dockerfile (facoltativo): consente di creare un'app per le funzioni in contenitori dal progetto usando un'immagine di base approvata per il progetto. Questo file viene visualizzato solo quando si esegue il comando Azure Functions: Create New Containerized Project.... È possibile aggiungere un Dockerfile a un progetto esistente usando il func init --docker-only comando in Core Tools.

A seconda della lingua, vengono creati questi altri file:

A questo punto, è possibile eseguire la funzione trigger HTTP in locale.

Aggiungere una funzione al progetto

È possibile aggiungere una nuova funzione a un progetto esistente in base a uno dei modelli di trigger di Funzioni predefiniti. Per aggiungere un nuovo trigger di funzione, selezionare F1 per aprire il riquadro comandi e quindi trovare ed eseguire il comando Funzioni di Azure: Crea funzione. Seguire le istruzioni per scegliere il tipo di trigger e definire gli attributi necessari del trigger. Se il trigger richiede una chiave di accesso o una stringa di connessione per connettersi a un servizio, prepararlo prima di creare il trigger della funzione.

Connettersi ai servizi

È possibile connettere la funzione ad altri servizi di Azure aggiungendo associazioni di input e output. Le associazioni connettono la funzione ad altri servizi senza dover scrivere il codice di connessione.

{
    "type": "queue",
    "direction": "out",
    "name": "msg",
    "queueName": "outqueue",
    "connection": "MyStorageConnection"
}

{
    "type": "queue",
    "direction": "out",
    "name": "msg",
    "queueName": "outqueue",
    "connection": "MyStorageConnection"
}

{
    "type": "queue",
    "direction": "out",
    "name": "msg",
    "queueName": "outqueue",
    "connection": "MyStorageConnection"
}

L'esempio seguente illustra la definizione della funzione dopo l'aggiunta di un'associazione di output di archiviazione code a una funzione attivata tramite HTTP:

[Function("HttpExample")]
public static MultiResponse Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req,
    FunctionContext executionContext)
{

public class MultiResponse
{
    [QueueOutput("outqueue",Connection = "AzureWebJobsStorage")]
    public string[] Messages { get; set; }
    public IActionResult HttpResponse { get; set; }
}

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)

@FunctionName("HttpExample")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

$outputMsg = $name
Push-OutputBinding -name msg -Value $outputMsg

@app.route(route="HttpExample")
@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")
def HttpExample(req: func.HttpRequest, msg: func.Out [func.QueueMessage]) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Accedere ad Azure

Prima di poter creare risorse di Azure o pubblicare l'app, è necessario accedere ad Azure.

1. Se non si è ancora effettuato l'accesso, selezionare l'icona di Azure nella barra attività. Successivamente, in Risorse, selezionare Accedi ad Azure.

   

   Se si è già connessi e si possono visualizzare le sottoscrizioni esistenti, passare alla sezione successiva. Se non si dispone ancora di un account Azure, selezionare Crea un account Azure. Gli studenti possono selezionare Crea un account Microsoft Azure for Students.

2. Quando viene visualizzata la richiesta nel browser, selezionare l'account Azure e accedere con le credenziali corrispondenti. Se si crea un nuovo account, è possibile accedere dopo la creazione dell'account.

3. Dopo avere eseguito l'accesso, è possibile chiudere la nuova finestra del browser. Le sottoscrizioni che appartengono all'account Azure vengono visualizzate nella barra laterale.

Creazione di risorse Azure

Prima di poter pubblicare il progetto di Funzioni in Azure, è necessario disporre di un'app per le funzioni e delle risorse correlate nella sottoscrizione di Azure per eseguire il codice. L'app per le funzioni fornisce un contesto di esecuzione per le funzioni. Quando si pubblica da Visual Studio Code in un'app per le funzioni in Azure, il progetto viene inserito in un pacchetto e distribuito nell'app per le funzioni selezionata nella sottoscrizione di Azure.

Quando si crea un'app per le funzioni in Azure, è possibile scegliere un percorso di creazione rapida dell'app per le funzioni usando le impostazioni predefinite o un percorso che offre opzioni avanzate, ad esempio l'uso di risorse di Azure esistenti. In questo modo, si ha maggiore controllo sulla creazione delle risorse remote.

Creare una distribuzione di App Contenitore di Azure

Si usa Visual Studio Code per creare risorse di Azure per un progetto di codice in contenitori. Quando l'estensione rileva la presenza di un Dockerfile durante la creazione di risorse, chiede se si vuole distribuire l'immagine del contenitore anziché solo il codice. Visual Studio Code crea un ambiente di App Contenitore di Azure per il progetto di codice in contenitori integrato con Funzioni di Azure. Per altre informazioni, vedere Hosting di App contenitore di Azure di Funzioni di Azure.

Il processo di creazione dipende dal fatto che si scelga una creazione rapida o che sia necessario usare le opzioni avanzate:

Per altre informazioni sulle risorse necessarie per eseguire le funzioni in contenitori in App contenitore, vedere Risorse necessarie.

Distribuire i file di progetto

È consigliabile configurare la distribuzione continua in modo che l'app per le funzioni in Azure venga aggiornata quando si aggiornano i file di origine nel percorso di origine connesso. È anche possibile distribuire i file di progetto da Visual Studio Code. Quando si pubblica da Visual Studio Code, è possibile sfruttare la tecnologia di distribuzione zip.

1. Nel riquadro comandi immettere quindi selezionare Funzioni di Azure: Distribuisci nell'app per le funzioni.

2. Selezionare l'app per le funzioni appena creata. Quando viene richiesto di sovrascrivere le distribuzioni precedenti, selezionare Distribuisci per distribuire il codice della funzione nella nuova risorsa dell'app per le funzioni.

3. Al termine della distribuzione, selezionare Visualizza output per visualizzare i risultati della creazione e della distribuzione, incluse le risorse di Azure create. Se non si riesce a visualizzare la notifica, selezionare l'icona della campana nell'angolo in basso a destra per visualizzarla di nuovo.

   

Ottenere l'URL di una funzione attivata tramite HTTP in Azure

Per chiamare una funzione attivata tramite HTTP da un client, è necessario l'URL della funzione, disponibile dopo la distribuzione nell'app per le funzioni. Questo URL include tutte le chiavi di funzione necessarie. È possibile usare l'estensione per ottenere questi URL per le funzioni distribuite. Se si vuole solo eseguire la funzione remota in Azure, usare la funzionalità usa la funzione Execute ora dell'estensione.

1. Selezionare F1 per aprire il riquadro comandi e quindi trovare ed eseguire il comando Funzioni di Azure: Copia URL funzione.

2. Seguire le istruzioni per selezionare l'app per le funzioni in Azure e quindi il trigger HTTP specifico che si vuole richiamare.

L'URL della funzione viene copiato negli Appunti, insieme alle chiavi necessarie passate dal parametro di query code. Usare uno strumento HTTP per inviare richieste POST o un browser per inviare richieste GET alla funzione remota.

Quando l'estensione ottiene l'URL di una funzione in Azure, l'estensione usa l'account Azure per recuperare automaticamente le chiavi necessarie per avviare la funzione. Altre informazioni sulle chiavi di accesso alle funzioni. L'avvio di funzioni attivate non HTTP richiede l'uso della chiave di amministrazione.

Eseguire funzioni

L'estensione Funzioni di Azure consente di eseguire singole funzioni. È possibile eseguire funzioni nel progetto nel computer di sviluppo locale o nella sottoscrizione di Azure.

Per le funzioni trigger HTTP, l'estensione chiama l'endpoint HTTP. Per altri tipi di trigger, l'estensione chiama le API amministratore per avviare la funzione. Il corpo del messaggio della richiesta inviata alla funzione dipende dal tipo di trigger. Quando un trigger richiede dati di test, viene richiesto di immettere i dati in un formato JSON specifico.

Eseguire funzioni in Azure

Per eseguire una funzione in Azure da Visual Studio Code, seguire questa procedura:

1. Nel riquadro comandi immettere Funzioni di Azure: Esegui funzione ora e selezionare la sottoscrizione di Azure.

2. Nell'elenco scegliere l'app per le funzioni in Azure. Se l'app per le funzioni non viene visualizzata, assicurarsi di aver eseguito l'accesso alla sottoscrizione corretta.

3. Nell'elenco scegliere la funzione da eseguire. In Immettere il corpo della richiesta digitare il corpo del messaggio della richiesta e premere INVIO per inviare il messaggio di richiesta alla funzione.

   Il testo predefinito in Immettere il corpo della richiesta indica il formato del corpo. Se l'app per le funzioni non ha funzioni, viene visualizzato un errore di notifica con questo errore.

   Quando la funzione viene eseguita in Azure e restituisce una risposta, Visual Studio Code visualizza una notifica.

È anche possibile eseguire la funzione dall'area Azure: Funzioni aprendo il menu di scelta rapida per la funzione che si vuole eseguire dall'app per le funzioni nella sottoscrizione di Azure e quindi selezionando Esegui funzione ora....

Quando si eseguono le funzioni in Azure da Visual Studio Code, l'estensione usa l'account Azure per recuperare automaticamente le chiavi necessarie per avviare la funzione. Altre informazioni sulle chiavi di accesso alle funzioni. L'avvio di funzioni attivate non HTTP richiede l'uso della chiave di amministrazione.

Eseguire funzioni localmente

Il runtime locale è lo stesso runtime che ospita l'app per le funzioni in Azure. Le impostazioni locali vengono lette dal file local.settings.json. Per eseguire il progetto funzioni in locale, è necessario soddisfare altri requisiti.

Configurare il progetto per l'esecuzione in locale

Il runtime di Funzioni usa internamente un account di archiviazione di Azure per tutti i tipi di trigger diversi da HTTP e webhook. È quindi necessario impostare la chiave Values.AzureWebJobsStorage su una stringa di connessione valida dell'account di archiviazione di Azure.

Questa sezione usa l'estensione Archiviazione di Azure per Visual Studio Code con Azure Storage Explorer per connettersi e recuperare la stringa di connessione di archiviazione.

Per impostare la stringa di connessione dell'account di archiviazione:

1. In Visual Studio aprire Cloud Explorer, espandere Account di archiviazione>Your Storage Account (Account di archiviazione personale), e quindi selezionare Proprietà e copiare il valore Stringa di connessione primaria.

2. Nel progetto aprire il file local.settings.json e impostare il valore della chiave AzureWebJobsStorage sulla stringa di connessione copiata.

3. Ripetere il passaggio precedente per aggiungere chiavi univoche alla matrice di Valori per tutte le altre connessioni richieste dalle funzioni.

Per maggiori informazioni, vedere File di impostazioni locali.

Eseguire il debug delle funzioni in locale

Per eseguire il debug delle funzioni, selezionare F5. Se Core Tools non è disponibile, viene richiesto di installarlo. Quando Core Tools è installato e in esecuzione, l'output viene visualizzato nel terminale. Questo passaggio equivale all'esecuzione del comando func start Core Tools dal terminale, ma con attività di compilazione aggiuntive e un debugger collegato.

Quando il progetto è in esecuzione, è possibile usare la funzionalità Esegui funzione ora... dell'estensione per attivare le funzioni come si farebbe quando il progetto viene distribuito in Azure. Con il progetto in esecuzione in modalità di debug, i punti di interruzione vengono raggiunti in Visual Studio Code come previsto.

1. Nel riquadro comandi immettere Funzioni di Azure: Esegui funzione ora e scegliere Progetto locale.

2. Scegliere la funzione da eseguire nel progetto e digitare il corpo del messaggio della richiesta in Immettere il corpo della richiesta. Premere INVIO per inviare il messaggio di richiesta alla funzione. Il testo predefinito in Immettere il corpo della richiesta deve indicare il formato del corpo. Se l'app per le funzioni non ha funzioni, viene visualizzato un errore di notifica con questo errore.

3. Quando la funzione viene eseguita in locale e dopo la ricezione della risposta, viene generata una notifica in Visual Studio Code. Le informazioni sull'esecuzione della funzione sono visualizzate nel riquadro Terminale.

Le chiavi non sono necessarie durante l'esecuzione in locale, e questo vale sia per i tasti funzione che per i tasti di livello amministratore.

Usare le impostazioni dell'app in locale

Quando si esegue in un'app per le funzioni in Azure, le impostazioni richieste dalle funzioni vengono archiviate in modo sicuro nelle impostazioni dell'app. Durante lo sviluppo locale, queste impostazioni vengono invece aggiunte alla raccolta Values nel file local.settings.json. Il file local.settings.json archivia anche le impostazioni usate dagli strumenti di sviluppo locali.

Gli elementi nella raccolta di Values nel file di local.settings.json del progetto sono destinati a eseguire il mirroring degli elementi nelle impostazioni di applicazione dell'app per le funzioni in Azure.

Per impostazione predefinita, queste impostazioni non vengono migrate automaticamente quando il progetto viene pubblicato in Azure. Al termine della pubblicazione, è possibile pubblicare le impostazioni da local.settings.json all'app per le funzioni in Azure. Per altre informazioni, vedere Pubblicare le impostazioni dell'applicazione.

I valori in ConnectionStrings non vengono mai pubblicati.

Impostazioni dell'applicazione in Azure

Le impostazioni nel file local.settings.json nel progetto devono corrispondere alle impostazioni dell'applicazione nell'app per le funzioni in Azure. Tutte le impostazioni aggiunte a local.settings.json devono essere aggiunte anche all'app funzione in Azure. Queste impostazioni non vengono caricate automaticamente quando si pubblica il progetto. Analogamente, tutte le impostazioni create nell'app per le funzioni nel portale devono essere scaricate nel progetto locale.

Pubblicare le impostazioni dell'applicazione

Il modo più semplice per pubblicare le impostazioni necessarie nell'app per le funzioni in Azure consiste nell'usare il collegamento Carica impostazioni visualizzato dopo la pubblicazione del progetto:

È anche possibile pubblicare le impostazioni usando il comando Funzioni di Azure: Carica impostazione locale nel riquadro comandi. È possibile aggiungere singole impostazioni alle impostazioni dell'applicazione in Azure usando il comando Funzioni di Azure: Aggiungi nuova impostazione.

Se il file locale è crittografato, viene decrittografato, pubblicato e crittografato di nuovo. Se sono presenti impostazioni con valori in conflitto nelle due posizioni, viene richiesto di scegliere come procedere.

Visualizzare le impostazioni dell'app esistenti nell'area Azure: Funzioni espandendo la sottoscrizione, l'app per le funzioni e le impostazioni dell'applicazione.

Scaricare le impostazioni da Azure

Se sono state create le impostazioni dell'applicazione in Azure, è possibile scaricarle nel file local.settings.json usando il comando Funzioni di Azure: Scaricare le impostazioni remote.

Come per il caricamento, se il file locale è crittografato, viene decrittografato, aggiornato e crittografato di nuovo. Se sono presenti impostazioni con valori in conflitto nelle due posizioni, viene richiesto di scegliere come procedere.

Installare le estensioni di binding

Ad eccezione dei trigger HTTP e timer, i binding vengono implementati in pacchetti di estensione.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.<BINDING_TYPE_NAME> --version <TARGET_VERSION>

dotnet add package Microsoft.Azure.WebJobs.Extensions.<BINDING_TYPE_NAME> --version <TARGET_VERSION>

{
    "version": "2.0",
    "extensionBundle": {
        "id": "Microsoft.Azure.Functions.ExtensionBundle",
        "version": "[3.*, 4.0.0)"
    }
}

Monitoraggio delle funzioni

Quando si eseguono funzioni in locale, i dati di log vengono trasmessi alla console del terminale. È anche possibile ottenere dati di log quando il progetto di Funzioni è in esecuzione in un'app per le funzioni in Azure. È possibile connettersi ai log di streaming in Azure per visualizzare i dati di log quasi in tempo reale. È consigliabile abilitare Application Insights per una comprensione più completa del comportamento dell'app per le funzioni.

Application Insights

È consigliabile monitorare l'esecuzione delle funzioni integrando l'app per le funzioni con Application Insights. Quando si crea un'app per le funzioni nel portale di Azure, questa integrazione viene eseguita per impostazione predefinita. Quando si crea l'app per le funzioni durante la pubblicazione di Visual Studio, è necessario integrare manualmente Application Insights. Per informazioni su come, vedere Abilitare l'integrazione di Application Insights.

Per altre informazioni sul monitoraggio con Application Insights, vedere Monitorare Funzioni di Azure.

Informazioni di riferimento sul riquadro comandi

L'estensione Funzioni di Azure offre un'interfaccia grafica utile nell'area per interagire con le app per le funzioni in Azure. La stessa funzionalità è disponibile anche come comandi nel riquadro comandi (F1). Questi comandi di Funzioni di Azure sono disponibili:

Passaggi successivi

Per altre informazioni sugli strumenti di base di Funzioni di Azure, vedere Usare Azure Functions Core Tools.

Per altre informazioni sullo sviluppo di funzioni come librerie di classi .NET, vedere Guida di riferimento per gli sviluppatori C# di Funzioni di Azure. Questo articolo fornisce anche collegamenti a esempi d'uso degli attributi per dichiarare i vari tipi di associazioni supportati da Funzioni di Azure.