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

Articolo
05/22/2024

In questo articolo vengono usati gli strumenti da riga di comando per creare una funzione C# che risponde alle richieste HTTP. Dopo aver testato il codice in locale, verrà distribuito nell'ambiente serverless di Funzioni di Azure.

Questo articolo crea una funzione attivata da HTTP eseguita in .NET 8 in un processo di lavoro isolato. Per informazioni sulle versioni di .NET supportate per le funzioni C#, vedere Versioni supportate. È inoltre disponibile una versione basata su Visual Studio Code di questo articolo.

Le procedure illustrate in questa guida di avvio rapido comportano l'addebito di qualche centesimo (USD) o meno nell'account Azure.

Configurare l'ambiente locale

Per eseguire le procedure descritte è necessario:

.NET 8.0 SDK.
Uno degli strumenti seguenti per la creazione di risorse di Azure:
- Interfaccia della riga di comando di Azure 2.4 o versione successiva.
- Il modulo Azure Az PowerShell versione 5.9.0 o successiva.

È anche necessario un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.

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 altre informazioni su altri programmi di installazione basati su pacchetti, vedere 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	Versione
Debian 12	`bookworm`
Debian 11	`bullseye`
Debian 10	`buster`
Debian 9	`stretch`
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 un progetto di funzione locale

In Funzioni di Azure un progetto di funzione è un contenitore per una o più funzioni singole che rispondono ognuna a un trigger specifico. Tutte le funzioni di un progetto condividono le stesse configurazioni locali e di hosting. In questa sezione viene creato un progetto di funzione che contiene una singola funzione.

Eseguire il comando func init come indicato di seguito per creare un progetto di Funzioni in una cartella denominata LocalFunctionProj con il runtime specificato:
```
func init LocalFunctionProj --worker-runtime dotnet-isolated --target-framework net8.0
```
Passare alla cartella del progetto:
```
cd LocalFunctionProj
```
Questa cartella 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.
Aggiungere una funzione al progetto usando il comando seguente, in cui l'argomento --name è il nome univoco della funzione (HttpExample) e l'argomento --template specifica il trigger della funzione (HTTP).
```
func new --name HttpExample --template "HTTP trigger" --authlevel "anonymous"
```
func new crea un file di codice HttpExample.cs.

(Facoltativo) Esaminare il contenuto del file

Se si vuole, è possibile passare a Eseguire la funzione localmente ed esaminare il contenuto del file in un secondo momento.

HttpExample.cs

HttpExample.cs contiene un metodo di Run che riceve i dati della richiesta nella variabile req come oggetto HttpRequest. Tale parametro è decorato con HttpTriggerAttribute, per definire il comportamento del trigger.

using System.Net;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace Company.Function
{
    public class HttpExample
    {
        private readonly ILogger<HttpExample> _logger;

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

        [Function("HttpExample")]
        public IActionResult Run([HttpTrigger(AuthorizationLevel.AuthLevelValue, "get", "post")] HttpRequest req)
        {            
            _logger.LogInformation("C# HTTP trigger function processed a request.");

            return new OkObjectResult("Welcome to Azure Functions!");
        }
    }
}

L'oggetto restituito è un oggetto IActionResult che contiene i dati restituiti alla risposta HTTP.

Per altre informazioni, vedere Trigger e associazioni HTTP di Funzioni di Azure.

Eseguire la funzione in locale

Eseguire la funzione avviando l'host di runtime locale di Funzioni di Azure nella cartella LocalFunctionProj:
```
func start
```
Verso la fine dell'output, verranno 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
 ...

 
```
Nota

Se HttpExample non viene visualizzato come illustrato sopra, è probabile che l'host non sia stato avviato dalla cartella radice del progetto. In tal caso, premere CTRL+C per arrestare l'host, passare alla cartella radice del progetto ed eseguire di nuovo il comando precedente.
Copiare l'URL della funzione HttpExample da questo output in un browser e passare all'URL della funzione e si dovrebbe ricevere un messaggio benvenuto in Funzioni di Azure.
Al termine, premere CTRL+C e scegliere y per arrestare l'host di Funzioni.

Creare le risorse di Azure di supporto per la funzione

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

Un gruppo di risorse, ovvero un contenitore logico di risorse correlate.
Un account di archiviazione, usato per mantenere lo stato e altre informazioni sulle funzioni.
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 seguenti per creare questi elementi. Sono supportati sia l'interfaccia della riga di comando di Azure che PowerShell.

Se non è già stato fatto, accedere ad Azure:
- Interfaccia della riga di comando di Azure
- Azure PowerShell
```
az login
```
Il comando az login consente di accedere all'account Azure.
```
Connect-AzAccount
```
Il cmdlet Connect-AzAccount consente di accedere all'account Azure.
Creare un gruppo di risorse denominato AzureFunctionsQuickstart-rg nell'area scelta:
- Interfaccia della riga di comando di Azure
- Azure PowerShell
```
az group create --name AzureFunctionsQuickstart-rg --location <REGION>
```
Il comando az group create crea un gruppo di risorse. Nel comando precedente sostituire <REGION> con un'area vicina usando un codice di area disponibile restituito dal comando az account list-locations.
```
New-AzResourceGroup -Name AzureFunctionsQuickstart-rg -Location <REGION>
```
Il comando New-AzResourceGroup crea un gruppo di risorse. In genere, il gruppo di risorse e le risorse vengono creati in un'area vicina alla propria, usando un'area disponibile restituita dal cmdlet Get-AzLocation.
Creare un account di archiviazione per utilizzo generico nel gruppo di risorse e nell'area:
- Interfaccia della riga di comando di Azure
- Azure PowerShell
```
az storage account create --name <STORAGE_NAME> --location <REGION> --resource-group AzureFunctionsQuickstart-rg --sku Standard_LRS --allow-blob-public-access false
```
Il comando az storage account create crea l'account di archiviazione.
```
New-AzStorageAccount -ResourceGroupName AzureFunctionsQuickstart-rg -Name <STORAGE_NAME> -SkuName Standard_LRS -Location <REGION> -AllowBlobPublicAccess $false
```
Il cmdlet New-AzStorageAccount crea l'account di archiviazione.
Nell'esempio precedente sostituire <STORAGE_NAME> con un nome appropriato 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.

Importante

L'account di archiviazione viene usato per archiviare dati importanti dell'app, a volte incluso il codice dell'applicazione stesso. È consigliabile limitare l'accesso da altre app e utenti all'account di archiviazione.

Creare l'app per le funzioni in Azure:
- Interfaccia della riga di comando di Azure
- Azure PowerShell
```
az functionapp create --resource-group AzureFunctionsQuickstart-rg --consumption-plan-location <REGION> --runtime dotnet-isolated --functions-version 4 --name <APP_NAME> --storage-account <STORAGE_NAME>
```
Il comando az functionapp create crea l'app per le funzioni in Azure.
```
New-AzFunctionApp -Name <APP_NAME> -ResourceGroupName AzureFunctionsQuickstart-rg -StorageAccount <STORAGE_NAME> -Runtime dotnet-isolated -FunctionsVersion 4 -Location '<REGION>'
```
Il cmdlet New-AzFunctionApp crea l'app per le funzioni in Azure.
Nell'esempio precedente sostituire <STORAGE_NAME> con il nome dell'account usato nel passaggio precedente e sostituire <APP_NAME> con un nome univoco a livello globale appropriato. <APP_NAME> è anche il dominio DNS predefinito per l'app per le funzioni.

Questo comando crea un'app per le funzioni che esegue il runtime del linguaggio specificato nel Piano a consumo di Funzioni di Azure, 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 monitorare l'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.

Distribuire il progetto di funzione in Azure

Dopo aver creato correttamente l'app per le funzioni in Azure, è ora possibile distribuire il progetto di funzioni locali 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

Richiamare la funzione in Azure

Poiché la funzione usa un trigger HTTP e supporta le richieste GET, è possibile richiamarla effettuando una richiesta HTTP al relativo URL. È più semplice eseguire questa operazione in un browser.

Copiare l'URL di richiamo completo visualizzato nell'output del comando publish nella barra degli indirizzi di un browser. Quando si passa a questo URL, il browser deve visualizzare un output simile a quello eseguito in locale.

Eseguire il comando seguente per visualizzare i log in streaming quasi in tempo reale:

func azure functionapp logstream <APP_NAME>

In una finestra del terminale separata o nel browser chiamare di nuovo la funzione remota. Nel terminale viene visualizzato un log dettagliato dell'esecuzione della funzione in Azure.

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 Azure Cosmos DB

Connettersi ad Archiviazione code di Azure

Condividi tramite