Condividi tramite

Sviluppare Funzioni di Azure con Visual Studio

Visual Studio consente di sviluppare, testare e distribuire funzioni della libreria di classi C# in Azure. Se questa esperienza è la prima con Funzioni di Azure, vedere Panoramica di Funzioni di Azure.

Per iniziare subito, è consigliabile completare l'Avvio rapido di Funzioni per Visual Studio.

Questo articolo fornisce informazioni dettagliate su come usare Visual Studio per sviluppare funzioni della libreria di classi C# e pubblicarle in Azure. Esistono due modelli per lo sviluppo di funzioni di libreria di classi C#: il modello di lavoro isolato e il modello in-process.

Stai leggendo la versione del modello di lavoratore isolato di questo articolo. È possibile selezionare il modello preferito nella parte superiore dell'articolo.

Si sta leggendo la versione del modello In-Process di questo articolo. È possibile selezionare il modello preferito nella parte superiore dell'articolo.

Importante

Il supporto per il modello in-process termina il 10 novembre 2026. È consigliabile eseguire la migrazione delle app al modello di lavoro isolato.

Se non diversamente specificato, le procedure e gli esempi mostrati sono per Visual Studio 2022. Per altre informazioni sulle versioni di Visual Studio 2022, vedere le note sulla versione o le note sulla versione di anteprima.

Prerequisiti

  • Visual Studio 2022, incluso il carico di lavoro sviluppo di Azure.

  • Altre risorse necessarie, ad esempio un account di archiviazione di Azure, vengono create nella sottoscrizione durante il processo di pubblicazione.

  • Se non si ha un account Azure, creare un account gratuito prima di iniziare.

Creare un progetto di Funzioni di Azure

Il modello di progetto Funzioni di Azure in Visual Studio crea un progetto di libreria di classi C# che è possibile pubblicare in un'app per le funzioni in Azure. È possibile usare un'app per le funzioni per raggruppare le funzioni in un'unità logica e semplificare la gestione, la distribuzione, il ridimensionamento e la condivisione delle risorse.

  1. Nel menu di Visual Studio selezionare File>Nuovo>Progetto.

  2. Nella finestra di dialogo Crea un nuovo progetto immettere le funzioni nella casella di ricerca, selezionare il modello Funzioni di Azure e quindi selezionare Avanti.

  3. Nella finestra di dialogo Configura il nuovo progetto , per Nome progetto, immettere un nome per il progetto e quindi selezionare Avanti. Il nome dell'app per le funzioni deve essere valido come spazio dei nomi C#, quindi non usare caratteri di sottolineatura, trattini o altri caratteri non alfanumerici.

  4. Nella finestra di dialogo Informazioni aggiuntive eseguire le azioni elencate nella tabella seguente:

    Impostazione Action Descrizione
    Funzioni ruolo di lavoro Selezionare .NET 8.0 Isolato (supporto a lungo termine). Visual Studio crea un progetto di funzione eseguito in un processo di lavoro isolato. Il processo di lavoro isolato supporta anche altre versioni di .NET e .NET Framework che non offrono supporto a lungo termine (LTS). Per altre informazioni, vedere Panoramica delle versioni del runtime per Funzioni di Azure.
    Function Selezionare Trigger HTTP. Visual Studio crea una funzione attivata da una richiesta HTTP.
    Usare Azurite per l'account _storage di runtime (AzureWebJobsStorage) Selezionare questa casella di controllo. Poiché un'app per le funzioni in Azure richiede un account di archiviazione, ne viene assegnato o creato uno quando si pubblica il progetto in Azure. Un HTTP trigger non usa una stringa di connessione dell'account di archiviazione. Tutti gli altri tipi di trigger richiedono una stringa di connessione valida per l'account di archiviazione.
    Livello di autorizzazione Selezionare Anonimo. Quando si usa questa impostazione di autorizzazione, qualsiasi client può attivare la funzione creata senza fornire una chiave. Questa configurazione semplifica il test della nuova funzione. Per maggiori informazioni, vedere Livello di autorizzazione.

    Screenshot della finestra di dialogo Informazioni aggiuntive di Visual Studio che mostra le impostazioni configurate, ad esempio una versione .NET isolata per il ruolo di lavoro di Funzioni.

    Impostazione Action Descrizione
    Funzioni ruolo di lavoro Selezionare .NET 8.0 In-process (Supporto a lungo termine). Visual Studio crea un progetto di funzione che viene eseguito in-process con la versione 4.x del runtime di Funzioni. Per altre informazioni, vedere Panoramica delle versioni del runtime per Funzioni di Azure.
    Function Selezionare Trigger HTTP. Visual Studio crea una funzione attivata da una richiesta HTTP.
    Usare Azurite per l'account _storage di runtime (AzureWebJobsStorage) Selezionare questa casella di controllo. Poiché un'app per le funzioni in Azure richiede un account di archiviazione, ne viene assegnato o creato uno quando si pubblica il progetto in Azure. Un HTTP trigger non usa una stringa di connessione dell'account di archiviazione. Tutti gli altri tipi di trigger richiedono una stringa di connessione valida per l'account di archiviazione.
    Livello di autorizzazione Selezionare Anonimo Quando si usa questa impostazione di autorizzazione, qualsiasi client può attivare la funzione creata senza fornire una chiave. Questa configurazione semplifica il test della nuova funzione. Per maggiori informazioni, vedere Livello di autorizzazione.

    Schermata della finestra di dialogo Informazioni aggiuntive di Visual Studio che mostra le impostazioni configurate, come una versione .NET In-Process del ruolo di lavoro di Funzioni.

    Assicurarsi di impostare Livello di autorizzazione su Anonimo. Se si seleziona il livello predefinito di Funzione, è necessario presentare la chiave di funzione nelle richieste di accesso all'endpoint della funzione.

  5. Selezionare Crea per creare il progetto di funzione e la funzione attivata da HTTP.

Dopo aver creato un progetto di Funzioni, il modello di progetto crea un progetto C#, installa i Microsoft.Azure.Functions.Worker pacchetti e Microsoft.Azure.Functions.Worker.Sdk NuGet e imposta il framework di destinazione.

Dopo aver creato un progetto di Funzioni, il modello di progetto crea un progetto C#, installa il Microsoft.NET.Sdk.Functions pacchetto NuGet e imposta il framework di destinazione.

Il nuovo progetto contiene i file seguenti:

  • host.json: questo file consente di configurare l'host di Funzioni. Queste impostazioni si applicano sia durante l'esecuzione in locale che nell'esecuzione in Azure. Per altre informazioni, vedere il riferimento su host.json.

  • local.settings.json: questo file mantiene le impostazioni usate quando si eseguono funzioni in locale. Queste impostazioni non vengono usate quando l'app viene eseguita in Azure. Per altre informazioni, vedere Usare le impostazioni dell'app in locale.

    Importante

    Poiché il filelocal.settings.json può contenere segreti, è necessario escluderlo dal controllo del codice sorgente del progetto. Nella finestra di dialogo Proprietà per questo file verificare che l'impostazione Copia nella directory di output sia impostata su Copia se più recente.

Per ulteriori informazioni, vedere Struttura del progetto nella guida del lavoratore isolato.

Per altre informazioni, vedere Progetto di libreria di classi per Funzioni.

Usare le impostazioni dell'app in locale

Quando l'app per le funzioni viene eseguita in Azure, le impostazioni richieste dalle funzioni vengono archiviate crittografate nelle impostazioni dell'app. Durante lo sviluppo locale, queste impostazioni vengono invece aggiunte alla Values raccolta 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 local.settings.json del progetto sono destinati a eseguire il mirroring degli elementi nelle impostazioni di applicazione dell'app per le funzioni in Azure.

Visual Studio non carica automaticamente le impostazioni in local.settings.json quando si pubblica il progetto. Per assicurarsi che queste impostazioni esistano anche nell'app per le funzioni in Azure, caricarle dopo la pubblicazione del progetto. Per altre informazioni, vedere Impostazioni dell'app per le funzioni. I valori di una ConnectionStrings raccolta non vengono pubblicati.

Il codice può anche leggere i valori delle impostazioni dell'app per le funzioni come variabili di ambiente. Per altre informazioni, vedere Variabili di ambiente.

Configurare il progetto per lo sviluppo locale

Il runtime di Funzioni usa internamente un account di archiviazione. Durante lo sviluppo, è possibile usare un account di archiviazione valido per questo account interno oppure usare l'emulatore Azurite.

Per tutti i tipi di trigger diversi da HTTP e webhook, è necessario impostare il valore della Values.AzureWebJobsStorage chiave nel file local.settings.json :

  • Per un account di archiviazione, impostare il valore alla stringa di connessione del proprio account di archiviazione.
  • Per l'emulatore, impostare il valore su UseDevelopmentStorage=true.

Se si utilizza l'emulatore, modificare questa impostazione inserendo una stringa di connessione reale dell'account di archiviazione prima della distribuzione. Per altre informazioni, vedere Emulatore di archiviazione locale.

Per impostare la stringa di connessione dell'account di archiviazione, seguire questa procedura:

  1. Accedere al portale di Azure e quindi passare all'account di archiviazione.

  2. Selezionare Sicurezza echiavi di accesso>. In key1 copiare il valore della stringa di connessione .

  3. Nel progetto di Visual Studio aprire il file local.settings.json . Impostare il valore della AzureWebJobsStorage chiave sulla stringa di connessione copiata.

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

Aggiungere una funzione al progetto

Nelle funzioni della libreria di classi C# le associazioni usate dalle funzioni vengono definite applicando attributi nel codice. Quando si creano i trigger di funzione dai modelli forniti, vengono applicati automaticamente gli attributi del trigger.

  1. In Esplora soluzioni, fare clic con il pulsante destro del mouse sul nodo del progetto e selezionare Aggiungi>Nuova funzione di Azure.

  2. Nella finestra di dialogo Aggiungi nuovo elemento selezionare Funzione di Azure e quindi aggiungi.

  3. Selezionare un trigger e quindi impostare le proprietà di associazione necessarie. Se si seleziona un trigger del servizio di archiviazione e si vuole configurare la connessione, selezionare la casella di controllo per configurare la connessione al trigger. L'esempio seguente mostra le impostazioni per creare una funzione attivata da un'archiviazione code.

    Screenshot della finestra di dialogo Nuova funzione di Azure per un trigger di coda, con il nome della stringa di connessione impostato su QueueStorage e la coda su myqueue-items.

  4. Seleziona Aggiungi. Se si seleziona la casella di controllo per la configurazione di una connessione di archiviazione nel passaggio precedente, viene visualizzata la pagina Connetti alle dipendenze . Selezionare un emulatore di archiviazione Azurite o Archiviazione di Azure e quindi selezionare Avanti.

    • Se si seleziona un emulatore di archiviazione Azurite, viene visualizzata la pagina Connetti all'emulatore di Storage Azurite . Seguire questa procedura:
      1. Seleziona Avanti.
      2. Nella pagina Riepilogo delle modifiche selezionare Fine. Visual Studio configura la dipendenza e crea la classe trigger.
    • Se si seleziona Archiviazione di Azure, viene visualizzata la pagina Connetti ad Archiviazione di Azure . Seguire questa procedura:
      1. Selezionare un account di archiviazione e quindi selezionare Avanti. Visual Studio tenta di connettersi all'account Azure e recuperare un endpoint.
      2. Seleziona Avanti.
      3. Nella pagina Riepilogo delle modifiche selezionare Fine. Visual Studio configura la dipendenza e crea la classe trigger.

    Questo esempio di trigger usa un'impostazione dell'applicazione per la connessione di archiviazione con una chiave denominata QueueStorage. Questa chiave, archiviata nel filelocal.settings.json, fa riferimento all'emulatore Azurite o a un account di archiviazione.

  5. Si esamini la classe appena aggiunta. La classe C# seguente rappresenta ad esempio una funzione di trigger di archiviazione code di base:

    Un Run() metodo è attribuito con Function. Questo attributo indica che il metodo è il punto di ingresso per la funzione.

    using System;
using Azure.Storage.Queues.Models;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace Company.Function;

public class QueueTriggerCSharp
{
    private readonly ILogger<QueueTriggerCSharp> _logger;

    public QueueTriggerCSharp(ILogger<QueueTriggerCSharp> logger)
    {
        _logger = logger;
    }

    [Function(nameof(QueueTriggerCSharp))]
    public void Run([QueueTrigger("PathValue", Connection = "ConnectionValue")] QueueMessage message)
    {
        _logger.LogInformation("C# Queue trigger function processed: {messageText}", message.MessageText);
    }
}

    Un metodo statico Run() viene attribuito con FunctionName. Questo attributo indica che il metodo è il punto di ingresso per la funzione.

    using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public class QueueTriggerCSharp
    {
        [FunctionName("QueueTriggerCSharp")]
        public void Run([QueueTrigger("PathValue", Connection = "ConnectionValue")]string myQueueItem, ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
        }
    }
}

Un attributo specifico dell'associazione viene applicato a ogni parametro di associazione fornito al metodo del punto di ingresso. L'attributo accetta le informazioni di associazione come parametri.

Nel codice precedente, il primo parametro ha un attributo QueueTrigger applicato, che indica una funzione di trigger di archiviazione code. Il nome della coda e il nome di impostazione della stringa di connessione vengono passati come parametri all'attributo QueueTrigger. Nella classe:

  • Il parametro nome coda deve corrispondere al nome della coda usata in un passaggio precedente per creare il trigger, ad esempio myqueue-items.
  • Il nome dell'impostazione della stringa di connessione deve corrispondere a quello usato in un passaggio precedente per creare il trigger, ad esempio QueueStorage.

Per altre informazioni, vedere Trigger di archiviazione code per Funzioni di Azure.

Usare la procedura precedente per aggiungere altre funzioni al progetto di funzioni dell'applicazione. Ogni funzione nel progetto può avere un trigger diverso, ma una funzione deve avere esattamente un trigger. Per altre informazioni, vedere Trigger e associazioni di Funzioni di Azure.

Aggiungere associazioni

Come nel caso dei trigger, le associazioni di input e output vengono aggiunte alla funzione come attributi di associazione. Per aggiungere associazioni a una funzione, seguire questa procedura:

  1. Assicurarsi di configurare il progetto per lo sviluppo locale.

  2. Aggiungere il pacchetto di estensione NuGet appropriato per ogni associazione specifica. Per i requisiti del pacchetto NuGet specifici del binding, vedere l'articolo di riferimento per il binding. Ad esempio, per i requisiti dei pacchetti relativi al trigger Event Hubs di Azure, vedere Trigger e associazioni Event Hubs di Azure per le Funzioni di Azure.

  3. Usare il comando seguente nella console di Gestione pacchetti per installare un pacchetto specifico:

    Install-Package Microsoft.Azure.Functions.Worker.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>

    Install-Package Microsoft.Azure.WebJobs.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>

    In questo codice sostituire <BINDING_TYPE> con il nome specifico dell'estensione di associazione e sostituire <TARGET_VERSION> con una versione specifica del pacchetto, ad esempio 4.0.0. Le versioni valide sono elencate nelle pagine dei singoli pacchetti in NuGet.org.

  4. Se ci sono impostazioni dell'app richieste dall'associazione, aggiungerle alla raccolta Values nel file di impostazioni locali.

    La funzione usa questi valori quando viene eseguito in locale. Quando la funzione viene eseguita nell'app per le funzioni in Azure, usa le impostazioni dell'app per le funzioni. Visual Studio semplifica la pubblicazione delle impostazioni locali in Azure.

  5. Aggiungere l'attributo di associazione appropriato per la firma del metodo. Nel codice seguente un messaggio di coda attiva la funzione Run. Il binding di output crea quindi un nuovo messaggio della coda con stesso testo, in una coda diversa.

     public class QueueTrigger
{
    private readonly ILogger _logger;

    public QueueTrigger(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<QueueTrigger>();
    }

    [Function("CopyQueueMessage")]
    [QueueOutput("myqueue-items-destination", Connection = "QueueStorage")]
    public string Run([QueueTrigger("myqueue-items-source", Connection = "QueueStorage")] string myQueueItem)
    {
        _logger.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
        return myQueueItem;
    }
}

    L'attributo QueueOutput definisce l'associazione nel metodo. Per più associazioni di output, è invece possibile posizionare questo attributo su una proprietà stringa dell'oggetto restituito. Per altre informazioni, vedere Più associazioni di output.

    public static class SimpleExampleWithOutput
{
    [FunctionName("CopyQueueMessage")]
    public static void Run(
        [QueueTrigger("myqueue-items-source", Connection = "QueueStorage")] string myQueueItem, 
        [Queue("myqueue-items-destination", Connection = "QueueStorage")] out string myQueueItemCopy,
        ILogger log)
    {
        log.LogInformation($"CopyQueueMessage function processed: {myQueueItem}");
        myQueueItemCopy = myQueueItem;
    }
}

    L'attributo Queue nel parametro out definisce l'associazione di output.

    La connessione all'archiviazione code viene ottenuta dall'impostazione QueueStorage. Per altre informazioni, vedere l'articolo di riferimento per l'associazione specifica.

Per un elenco completo delle associazioni supportate da Funzioni, vedere Associazioni supportate. Per un esempio più completo di questo scenario, vedere Connettere le funzioni ad Archiviazione di Azure con Visual Studio.

Eseguire funzioni localmente

È possibile usare Azure Functions Core Tools per eseguire progetti di Funzioni nel computer di sviluppo locale. Quando si seleziona F5 per eseguire il debug di un progetto di Funzioni, l'host di Funzioni locale (func.exe) inizia ad ascoltare su una porta locale (in genere 7071). Tutti gli endpoint di funzione chiamabili vengono scritti nell'output ed è possibile usare questi endpoint per testare le funzioni. Per altre informazioni, vedere Sviluppare Funzioni di Azure in locale con Core Tools. Viene richiesto di installare questi strumenti al primo avvio di una funzione da Visual Studio.

Importante

A partire dalla versione 4.0.6517 di Core Tools, i progetti di modelli in-process devono fare riferimento alla versione 4.5.0 o successiva di Microsoft.NET.Sdk.Functions. Se si usa una versione precedente, il func start comando genera un errore.

Per avviare la funzione in Visual Studio in modalità di debug, seguire questa procedura:

  1. Selezionare F5. Se richiesto, accettare la richiesta da Visual Studio per scaricare e installare Azure Functions Core Tools. Potrebbe anche essere necessario attivare un'eccezione del firewall in modo che gli strumenti possano gestire le richieste HTTP.

  2. Quando il progetto viene eseguito, testare il codice nello stesso modo in cui si testa una funzione distribuita.

    Quando si esegue Visual Studio in modalità di debug, i punti di interruzione vengono raggiunti come previsto.

Per uno scenario di test più dettagliato che usa Visual Studio, vedere Funzioni di test più avanti in questo articolo.

Pubblicazione in Azure

Quando si pubblica il progetto di Funzioni in Azure, Visual Studio usa la distribuzione zip per distribuire i file di progetto. Quando possibile, è anche necessario selezionare Esegui dal file di pacchetto in modo che il progetto venga eseguito nel pacchetto di distribuzione (.zip). Per altre informazioni, vedere Eseguire le funzioni da un file di pacchetto in Azure.

Non eseguire la distribuzione su Funzioni utilizzando Web Deploy (msdeploy).

Usare la procedura seguente per pubblicare il progetto in un'app per le funzioni in Azure:

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e quindi scegliere Pubblica.

  2. Nella pagina Pubblica effettuare le selezioni seguenti:

    • In Destinazione selezionare Azure e quindi avanti.
    • In Destinazione specifica selezionare App per le funzioni di Azure e quindi selezionare Avanti.
    • Nell'istanza di Funzioni selezionare Crea nuovo.

    Screenshot della pagina Pubblica. Nella sezione Istanza di Funzioni è visibile un gruppo di risorse ed è evidenziato Crea Nuovo.

  3. Creare una nuova istanza usando i valori specificati nella tabella seguente:

    Impostazione valore Descrizione
    Nome Nome globalmente univoco Il nome deve identificare in modo univoco la nuova app per le funzioni. Accettare il nome suggerito o immettere un nuovo nome. I caratteri seguenti sono validi: a-z, 0-9e -.
    Nome della sottoscrizione Nome della sottoscrizione L'app per le funzioni viene creata in una sottoscrizione di Azure. Accettare la sottoscrizione predefinita o selezionare una sottoscrizione diversa dall'elenco.
    Gruppo di risorse Nome del gruppo di risorse L'app per le funzioni viene creata in un gruppo di risorse. Per creare un nuovo gruppo di risorse, selezionare Nuovo. È anche possibile selezionare un gruppo di risorse esistente dall'elenco.
    Tipo di piano Flex Consumption Quando si pubblica il progetto in un'app per le funzioni eseguita in un piano a consumo Flex, è possibile pagare solo per le esecuzioni dell'app per le funzioni. Altri piani di hosting possono comportare costi più elevati.
    IMPORTANTE:
    Quando si crea un piano a Consumo Flessibile, è prima necessario selezionare Piano di servizio app e quindi riselezionare Consumo Flessibile per risolvere un problema con la finestra di dialogo.
    Sistema operativo Linux Il piano Flex Consumption richiede attualmente Linux.
    Ubicazione Posizione del servizio app Selezionare una località in un'area di Azure supportata dal piano a consumo Flex. Quando viene selezionata un'area non supportata, il pulsante Crea è disattivato.
    Dimensioni della memoria dell'istanza 2048 Le dimensioni di memoria delle istanze della macchina virtuale in cui viene eseguita l'app sono univoci per il piano Flex Consumption.
    Archiviazione di Azure Un account di archiviazione per utilizzo generico Il runtime di Funzioni richiede un account di archiviazione. Selezionare Nuovo per configurare un account di archiviazione per utilizzo generico. È anche possibile usare un account esistente che soddisfi i requisiti dell'account di archiviazione.
    Application Insights Un'istanza di Application Insights È consigliabile attivare l'integrazione di Application Insights per l'app per le funzioni. Selezionare Nuovo per creare una nuova istanza, in un'area di lavoro Log Analytics nuova o esistente. È anche possibile usare un'istanza esistente.

    Screenshot della nuova finestra di dialogo Crea app per le funzioni. I campi per il nome, la sottoscrizione, il gruppo di risorse, il piano e altre impostazioni sono compilati.

  4. Selezionare Crea per creare un'app per le funzioni e le relative risorse in Azure. Lo stato di creazione della risorsa viene visualizzato nell'angolo in basso a sinistra della finestra.

  5. Selezionare Fine. Verrà visualizzata la finestra Stato di avanzamento della creazione del profilo di pubblicazione. Al termine della creazione del profilo, selezionare Chiudi.

  6. Nella pagina del profilo di pubblicazione selezionare Pubblica per distribuire il pacchetto che contiene i file di progetto nella nuova app per le funzioni in Azure.

    Al termine della distribuzione, l'URL radice dell'app per le funzioni in Azure viene visualizzato in pubblica pagina del profilo.

  7. Nella pagina del profilo di pubblicazione passare alla sezione Hosting . Selezionare i puntini di sospensione (...) e quindi selezionare Apri nel portale di Azure. La nuova risorsa di Azure dell'app per le funzioni viene aperta nel portale di Azure.

    Screenshot della pagina del profilo di pubblicazione. Nella sezione Hosting è aperto il menu di scelta rapida con i puntini di sospensione, e la voce Apri nel portale di Azure è evidenziata.

Impostazioni dell'app per le funzioni

Visual Studio non carica automaticamente le impostazioni dell'app quando si pubblica il progetto. Se si aggiungono impostazioni al file local.settings.json , è necessario aggiungerle anche all'app per le funzioni in Azure.

Il modo più semplice per caricare le impostazioni necessarie nell'app per le funzioni in Azure consiste nel gestirle in Visual Studio. Nella pagina del profilo di pubblicazione passare alla sezione Hosting . Selezionare i puntini di sospensione (...) e quindi selezionare Gestire le impostazioni del servizio App di Azure.

Screenshot della sezione Hosting della pagina del profilo di pubblica. Il menu di scelta rapida con i puntini di sospensione è aperto e l'impostazione Gestisci Servizio app di Azure è evidenziata.

Quando si effettua la selezione, viene visualizzata la finestra di dialogo Impostazioni applicazione per l'app per le funzioni. È possibile usare questa finestra di dialogo per aggiungere le impostazioni dell'applicazione o modificarne quelle esistenti.

Screenshot della finestra di dialogo Impostazioni applicazione che mostra i valori locali e remoti per varie impostazioni e controlli per l'aggiunta e la modifica di valori.

Per ogni impostazione, il valore Local è il valore nel file local.settings.json e il valore Remote è il valore nell'app per le funzioni in Azure.

  • Per creare un'impostazione dell'app, selezionare Aggiungi impostazione.
  • Per copiare un valore di impostazione dal campo Locale al campo Remoto , selezionare Inserisci valore da Locale.

Le modifiche in sospeso vengono scritte nel file delle impostazioni locali e nell'app per le funzioni quando si seleziona OK.

Note

Per impostazione predefinita, il file local.settings.json non viene registrato nel controllo del codice sorgente. Di conseguenza, se si clona un progetto di Funzioni locale dal controllo del codice sorgente, il progetto non ha un file local.settings.json . È necessario creare manualmente il file local.settings.json nella radice del progetto in modo che la finestra di dialogo Impostazioni applicazione funzioni come previsto.

È anche possibile gestire le impostazioni dell'applicazione in questi altri modi:

Debug remoto

Per eseguire il debug remoto dell'app per le funzioni, è necessario pubblicare una configurazione di debug del progetto. È anche necessario attivare il debug remoto nell'app per le funzioni in Azure.

Questa sezione presuppone che venga pubblicata una configurazione di debug per l'app per le funzioni.

Considerazioni sul debug remoto

  • Il debug remoto non è consigliato in un servizio di produzione.
  • Per utilizzare il debug remoto, è necessario ospitare l'app per le funzioni in un piano Premium o piano di servizio app.
  • Il debug remoto è attualmente supportato solo quando si esegue l'app C# in Windows.
  • Se la funzionalità Just My Code è attivata in Visual Studio, disattivarla. Per istruzioni, vedere Abilitare o disabilitare Just My Code.
  • Evitare interruzioni prolungate in corrispondenza dei punti di interruzione durante l'uso del debug remoto. Quando un processo viene arrestato per più di qualche minuto, Azure lo considera un processo non reattivo e lo arresta.
  • Durante il debug, il server invia i dati a Visual Studio, che possono influire sugli addebiti per la larghezza di banda. Per informazioni sulle tariffe della larghezza di banda, vedere Calcolatore prezzi.
  • Il debug remoto viene disattivato automaticamente nell'app per le funzioni dopo 48 ore. Dopo questo punto, è necessario riattivare il debug remoto.

Collegare il debugger

Quando si esegue il debug di un'app del processo di lavoro isolato, è attualmente necessario collegare il debugger remoto a un processo .NET separato. Sono necessari anche diversi altri passaggi di configurazione.

Per collegare un debugger remoto a un'app per le funzioni in esecuzione in un processo separato dall'host di Funzioni, seguire questa procedura:

  1. Nella pagina del profilo di pubblicazione passare alla sezione Hosting . Selezionare i puntini di sospensione (...) e quindi selezionare Allega debugger.

    Visual Studio si connette all'app per le funzioni e attiva il debug remoto se non è già attivato.

    Note

    Poiché il debugger remoto non riesce a connettersi al processo host, potrebbe essere visualizzato un messaggio di errore. In ogni caso, il debugger locale non può accedere ai punti di interruzione o fornire un modo per esaminare le variabili o eseguire il codice.

  2. Nel menu Debug di Visual Studio selezionare Connetti a processo.

  3. Nella finestra di dialogo Connetti a processo seguire questa procedura:

    1. Accanto a Tipo di connessione selezionare Servizi app di Microsoft Azure.
    2. Accanto a Destinazione connessione selezionare Trova.

  4. Nella finestra di dialogo Collega a processo di Azure, cercare e selezionare l'app per le funzioni e quindi selezionare OK.

  5. Se richiesto, consentire l'accesso a Visual Studio tramite il firewall locale.

  6. Nella finestra di dialogo Connetti a processo selezionare Mostra processi per tutti gli utenti. Selezionare dotnet.exee quindi selezionare Collega.

    Screenshot della finestra di dialogo Allega a processo. Il tipo di connessione è Servizi app di Microsoft Azure. Nella tabella del processo, è selezionata dotnet.exe.

Al termine dell'operazione, siete collegati al codice della vostra libreria di classi C# in esecuzione in un processo di lavoro isolato. A questo punto, è possibile eseguire il debug dell'app per le funzioni come di consueto.

Per collegare un debugger remoto a un'applicazione di funzioni in esecuzione nello stesso processo con l'host delle funzioni, seguire questa procedura.

Nella pagina del profilo di pubblicazione passare alla sezione Hosting . Selezionare i puntini di sospensione (...) e quindi selezionare Allega debugger.

Visual Studio si connette all'app per le funzioni e attiva il debug remoto se non è già attivato. Individua e collega anche il debugger al processo host per l'app. A questo punto, è possibile eseguire il debug dell'app per le funzioni come di consueto.

Al termine del debug, è consigliabile disattivare il debug remoto.

Disattivare il debug remoto

Dopo aver completato il debug remoto del codice, è consigliabile disattivare il debug remoto nel portale di Azure. Il debug remoto viene disattivato automaticamente dopo 48 ore, nel caso in cui si dimentica.

  1. Nella pagina del profilo di pubblicazione passare alla sezione Hosting . Selezionare i puntini di sospensione (...) e quindi selezionare Apri nel portale di Azure. Il portale di Azure si apre sull'app per le funzioni in cui è distribuito il progetto.

  2. Nell'app per le funzioni selezionare Configurazione impostazioni> e quindi passare alla scheda Impostazioni generali. Accanto a Debug remoto selezionare Disattivato. Selezionare Salva e quindi Continua.

Dopo il riavvio dell'app per le funzioni, non è più possibile connettersi in remoto ai processi remoti. È possibile usare questa stessa scheda nel portale di Azure per attivare il debug remoto all'esterno di Visual Studio.

Funzioni del monitor

Il modo consigliato per monitorare le funzioni consiste nell'integrazione dell'app per le funzioni con Application Insights. È consigliabile attivare questa integrazione quando si crea l'app per le funzioni durante la pubblicazione di Visual Studio.

Se l'integrazione non è configurata durante la pubblicazione per qualche motivo, è comunque consigliabile attivare l'integrazione di Application Insights per l'app per le funzioni in Azure.

Per altre informazioni sull'uso di Application Insights per il monitoraggio, vedere Monitorare le esecuzioni in Funzioni di Azure.

Funzioni di test

Questa sezione descrive come creare un progetto di modello in-process C# che è possibile testare usando xUnit, uno strumento di unit testing open source per .NET.

Passaggio 1: Configurazione

Seguire questa procedura per configurare l'ambiente, incluso il progetto e le funzioni dell'app, necessari per supportare i test:

  1. In Visual Studio creare un progetto di Funzioni di Azure denominato Funzioni.

  2. Creare una funzione HTTP dal modello:

    1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Funzioni e quindi scegliere Aggiungi>nuova funzione di Azure.
    2. Nella finestra di dialogo Aggiungi nuovo elemento selezionare Funzione di Azure e quindi aggiungi.
    3. Selezionare Trigger HTTP e quindi Aggiungi.
    4. Rinominare la nuova classe MyHttpTrigger.

  3. Creare una funzione timer dal modello:

    1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Funzioni e quindi scegliere Aggiungi>nuova funzione di Azure.
    2. Nella finestra di dialogo Aggiungi nuovo elemento selezionare Funzione di Azure e quindi aggiungi.
    3. Selezionare Trigger timer e quindi Aggiungi.
    4. Rinominare la nuova classe MyTimerTrigger.

  4. Creare un'app di test xUnit all'interno della soluzione:

    1. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione che contiene il progetto Funzioni e quindi scegliere Aggiungi>nuovo progetto.
    2. Selezionare il modello progetto di test xUnit e quindi selezionare Avanti.
    3. Assegnare al progetto il nome Functions.Tests.

  5. Rimuovere i file di test predefiniti dal progetto Functions.Tests .

  6. Usare NuGet per aggiungere un riferimento dall'app di test a Microsoft.AspNetCore.Mvc. È possibile usare la console di Gestione pacchetti oppure seguire questa procedura:

    1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Functions.Tests e quindi scegliere Gestisci pacchetti NuGet.
    2. Cercare e installare Microsoft.AspNetCore.Mvc.

  7. Nell'app Funzioni.Testsaggiungere un riferimento all'app Funzioni:

    1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Functions.Tests e quindi scegliere Aggiungi>riferimento al progetto.
    2. Selezionare il progetto Funzioni e quindi fare clic su OK.

Passaggio 2: Creare classi di test

In questa sezione vengono create le classi usate per eseguire i test automatizzati.

Ogni funzione accetta un'implementazione di ILogger per gestire la registrazione dei messaggi. In alcuni test non viene registrato alcun messaggio o non importa come viene implementata la registrazione. Altri test devono valutare i messaggi registrati per determinare se un test deve essere superato.

  1. Creare una classe nel progetto Functions.Tests denominata NullScope e aggiungere il codice seguente. Questa classe fornisce un ambito fittizio. In un passaggio successivo si crea un'implementazione di ILogger che usa questo ambito.

    using System;

namespace Functions.Tests
{
    public class NullScope : IDisposable
    {
        public static NullScope Instance { get; } = new NullScope();

        private NullScope() { }

        public void Dispose() { }
    }
}

  2. Creare una classe nel progetto Functions.Tests denominata ListLogger e aggiungere il codice seguente. Questa classe gestisce un elenco interno di messaggi da valutare durante il test. Per implementare l'interfaccia necessaria ILogger , la classe usa l'ambito fittizio della NullScope classe . I casi di test passano l'ambito fittizio alla classe ListLogger.

    using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;

namespace Functions.Tests
{
    public class ListLogger : ILogger
    {
        public IList<string> Logs;

        public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;

        public bool IsEnabled(LogLevel logLevel) => false;

        public ListLogger()
        {
            this.Logs = new List<string>();
        }

        public void Log<TState>(LogLevel logLevel,
                                EventId eventId,
                                TState state,
                                Exception exception,
                                Func<TState, Exception, string> formatter)
        {
            string message = formatter(state, exception);
            this.Logs.Add(message);
        }
    }
}

    La ListLogger classe implementa i membri seguenti, come contratto dall'interfaccia ILogger :

    • BeginScope: gli ambiti aggiungono contesto alla registrazione. In questo caso, il test punta all'istanza statica della NullScope classe per consentire il funzionamento del test.
    • IsEnabled: viene fornito un valore predefinito di false .
    • Log: questo metodo usa la funzione fornita formatter per formattare il messaggio. Il metodo aggiunge quindi il testo risultante all'insieme Logs .

    La raccolta Logs è un'istanza di List<string> e viene inizializzata nel costruttore.

  3. Creare un file di codice nel progetto Functions.Tests denominato LoggerTypes.cs e aggiungere il codice seguente:

    namespace Functions.Tests
{
    public enum LoggerTypes
    {
        Null,
        List
    }
}

    Questa enumerazione specifica il tipo di logger usato dai test.

  4. Creare una classe nel progetto Functions.Tests denominata TestFactory e aggiungere il codice seguente:

    using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Internal;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Primitives;
using System.Collections.Generic;

namespace Functions.Tests
{
    public class TestFactory
    {
        public static IEnumerable<object[]> Data()
        {
            return new List<object[]>
            {
                new object[] { "name", "Bernardo" },
                new object[] { "name", "Ananya" },
                new object[] { "name", "Vlad" }

            };
        }

        private static Dictionary<string, StringValues> CreateDictionary(string key, string value)
        {
            var qs = new Dictionary<string, StringValues>
            {
                { key, value }
            };
            return qs;
        }

        public static HttpRequest CreateHttpRequest(string queryStringKey, string queryStringValue)
        {
            var context = new DefaultHttpContext();
            var request = context.Request;
            request.Query = new QueryCollection(CreateDictionary(queryStringKey, queryStringValue));
            return request;
        }

        public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)
        {
            ILogger logger;

            if (type == LoggerTypes.List)
            {
                logger = new ListLogger();
            }
            else
            {
                logger = NullLoggerFactory.Instance.CreateLogger("Null Logger");
            }

            return logger;
        }
    }
}

    La classe TestFactory implementa i seguenti membri:

    • Data: questa proprietà restituisce una raccolta IEnumerable di dati di esempio. Le coppie chiave-valore rappresentano i valori passati in una stringa di query.
    • CreateDictionary: questo metodo accetta una coppia chiave-valore come argomento. Restituisce una nuova istanza di Dictionary, utilizzata per creare un'istanza di QueryCollection che rappresenta i valori della stringa di query.
    • CreateHttpRequest: questo metodo crea una richiesta HTTP inizializzata con i parametri della stringa di query specificati.
    • CreateLogger: questo metodo restituisce un'implementazione di ILogger usata per il test. L'implementazione ILogger dipende dal tipo di logger specificato. Se viene specificato un tipo di elenco, l'istanza ListLogger tiene traccia dei messaggi registrati disponibili per la valutazione nei test.

  5. Creare una classe nel progetto Functions.Tests denominata FunctionsTests e aggiungere il codice seguente:

    using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Xunit;

namespace Functions.Tests
{
    public class FunctionsTests
    {
        private readonly ILogger logger = TestFactory.CreateLogger();

        [Fact]
        public async void Http_trigger_should_return_known_string()
        {
            var request = TestFactory.CreateHttpRequest("name", "Bernardo");
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal("Hello, Bernardo. This HTTP triggered function executed successfully.", response.Value);
        }

        [Theory]
        [MemberData(nameof(TestFactory.Data), MemberType = typeof(TestFactory))]
        public async void Http_trigger_should_return_known_string_from_member_data(string queryStringKey, string queryStringValue)
        {
            var request = TestFactory.CreateHttpRequest(queryStringKey, queryStringValue);
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal($"Hello, {queryStringValue}. This HTTP triggered function executed successfully.", response.Value);
        }

        [Fact]
        public void Timer_should_log_message()
        {
            var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
            new MyTimerTrigger().Run(null, logger);
            var msg = logger.Logs[0];
            Assert.Contains("C# Timer trigger function executed at", msg);
        }
    }
}

    Questa classe implementa i membri seguenti:

    • Http_trigger_should_return_known_string: questo test usa il valore name=Bernardo della stringa di query per creare una richiesta a una funzione HTTP. Questo test verifica che venga restituita la risposta prevista.
    • Http_trigger_should_return_string_from_member_data: questo test usa attributi xUnit per fornire dati di esempio alla funzione HTTP.
    • Timer_should_log_message: questo test crea un'istanza di ListLogger e la passa a una funzione timer. Dopo l'esecuzione della funzione, il log viene controllato per assicurarsi che il messaggio previsto sia presente.

  6. Per accedere alle impostazioni dell'applicazione nei test, è possibile inserire un'implementazione IConfiguration con valori di variabile di ambiente fittizi nella funzione.

Passaggio 3: Eseguire test

Per eseguire i test in Visual Studio, selezionare Visualizza> Esploratest. In Esplora test selezionare Esegui>tutti i test nella visualizzazione.

Screenshot di Visual Studio. Editor elenco dei test mostra che sono stati superati cinque test. In Esplora soluzioni sono visibili i progetti Funzioni e Functions.Test.

Passaggio 4: Eseguire il debug dei test

Per eseguire il debug dei test, impostare un punto di interruzione in un test. In Esplora test, selezionare Esegui>Debug Ultima Esecuzione.

Contenuti correlati

  • Last updated on