Avvio rapido: Creare una funzione Go o Rust in Azure con Visual Studio Code

• C#
• Java
• JavaScript
• PowerShell
• Python
• TypeScript
• Altro (Go/Rust)

In questo articolo si userà Visual Studio Code per creare una funzione gestore personalizzato che risponde alle richieste HTTP. Dopo aver testato il codice in locale, verrà distribuito nell'ambiente serverless di Funzioni di Azure.

I gestori personalizzati possono essere usati per creare funzioni in qualsiasi linguaggio o runtime eseguendo un processo server HTTP. Questo articolo supporta sia Go che Rust.

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

Configurare il tuo ambiente

Prima di iniziare, verificare che siano soddisfatti i requisiti seguenti:

Go

• Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.

• Visual Studio Code in una delle piattaforme supportate.

• Estensione Funzioni di Azure per Visual Studio Code.

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

Rust

• Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.

• Visual Studio Code in una delle piattaforme supportate.

• Estensione Funzioni di Azure per Visual Studio Code.

• Toolchain Rust con rustup. Usare il comando rustc --version per controllare la versione in uso.

Installare o aggiornare Core Tools

L'estensione Funzioni di Azure per Visual Studio Code si integra con Azure Functions Core Tools in modo da poter eseguire ed svolgere il debug delle funzioni in locale in Visual Studio Code usando il runtime di Funzioni di Azure. Prima di iniziare, è consigliabile installare Core Tools in locale o aggiornare un'installazione esistente per usare la versione più recente.

In Visual Studio Code selezionare F1 per aprire il riquadro comandi e quindi cercare ed eseguire il comando Funzioni di Azure: installare o aggiorna Core Tools.

Questo comando tenta di avviare un'installazione basata su pacchetto della versione più recente di Core Tools o di aggiornare un'installazione basata su pacchetti esistente. Se nel computer locale non è installato npm o Homebrew, è necessario installare o aggiornare manualmente Core Tools.

Creare il progetto locale

In questa sezione si usa Visual Studio Code per creare un progetto di gestori personalizzati di Funzioni di Azure locale. Più avanti in questo articolo verrà pubblicato il codice della funzione in Azure.

1. In Visual Studio Code premere F1 per aprire il riquadro comandi e cercare ed eseguire il comando Azure Functions: Create New Project....

2. Scegliere la posizione della directory per l'area di lavoro del progetto e quindi scegliere Seleziona. È necessario creare una nuova cartella o scegliere una cartella vuota per l'area di lavoro del progetto. Non scegliere una cartella di progetto che fa già parte di un'area di lavoro.

3. Quando richiesto, immettere le informazioni seguenti:

   Richiesta	Selezione
   Selezionare un linguaggio per il progetto di funzione	Scegliere Custom Handler.
   Selezionare un modello per la prima funzione del progetto	Scegliere HTTP trigger.
   Specificare un nome di funzione	Digitare HttpExample.
   Livello di autorizzazione	Scegliere Anonymous, che consente a chiunque di chiamare l'endpoint della funzione. Per altre informazioni, vedere Livello di autorizzazione.
   Selezionare come si vuole aprire il progetto	Scegliere Open in current window.

   Usando queste informazioni, Visual Studio Code genera un progetto di Funzioni di Azure con un trigger HTTP. È possibile visualizzare i file di progetto locali in Explorer.

Creare e compilare la funzione

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

Go

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

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

   package main
   
   import (
       "fmt"
       "log"
       "net/http"
       "os"
   )
   
   func helloHandler(w http.ResponseWriter, r *http.Request) {
       message := "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.\n"
       name := r.URL.Query().Get("name")
       if name != "" {
           message = fmt.Sprintf("Hello, %s. This HTTP triggered function executed successfully.\n", name)
       }
       fmt.Fprint(w, message)
   }
   
   func main() {
       listenAddr := ":8080"
       if val, ok := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT"); ok {
           listenAddr = ":" + val
       }
       http.HandleFunc("/api/HttpExample", helloHandler)
       log.Printf("About to listen on %s. Go to https://127.0.0.1%s/", listenAddr, listenAddr)
       log.Fatal(http.ListenAndServe(listenAddr, nil))
   }
   

3. Premere CTRL+ MAIUSC + ` o selezionare Nuovo terminale dal menu Terminale per aprire un nuovo terminale integrato in VS Code.

4. Compilare il gestore personalizzato usando il comando seguente. Un file eseguibile denominato handler (handler.exe in Windows) viene restituito nella cartella radice dell'app per le funzioni.

   go build handler.go
   

   

Rust

1. Premere CTRL+ MAIUSC + ` o selezionare Nuovo terminale dal menu Terminale per aprire un nuovo terminale integrato in VS Code.

2. Nella radice dell'app per le funzioni (la stessa cartella di host.json), inizializzare un progetto Rust denominato handler.

   cargo init --name handler
   

3. In Cargo.toml aggiungere le dipendenze seguenti necessarie per completare questa guida introduttiva. Nell'esempio viene usato il framework del server Web warp.

   [dependencies]
   warp = "0.3"
   tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
   

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

   use std::collections::HashMap;
   use std::env;
   use std::net::Ipv4Addr;
   use warp::{http::Response, Filter};
   
   #[tokio::main]
   async fn main() {
       let example1 = warp::get()
           .and(warp::path("api"))
           .and(warp::path("HttpExample"))
           .and(warp::query::<HashMap<String, String>>())
           .map(|p: HashMap<String, String>| match p.get("name") {
               Some(name) => Response::builder().body(format!("Hello, {}. This HTTP triggered function executed successfully.", name)),
               None => Response::builder().body(String::from("This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.")),
           });
   
       let port_key = "FUNCTIONS_CUSTOMHANDLER_PORT";
       let port: u16 = match env::var(port_key) {
           Ok(val) => val.parse().expect("Custom Handler port is not a number!"),
           Err(_) => 3000,
       };
   
       warp::serve(example1).run((Ipv4Addr::LOCALHOST, port)).await
   }
   

5. Compilare un file binario per il gestore personalizzato. Un file eseguibile denominato handler (handler.exe in Windows) viene restituito nella cartella radice dell'app per le funzioni.

   cargo build --release
   cp target/release/handler .
   

   

Configurare l'app per le funzioni

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

1. Aprire host.json.

2. Nella sezione customHandler.description impostare il valore di defaultExecutablePath su handler (in Windows, impostarlo su handler.exe).

3. Nella sezione customHandler aggiungere una proprietà denominata enableForwardingHttpRequest e impostarne il valore su true. Per le funzioni costituite solo da un trigger HTTP, questa impostazione semplifica la programmazione consentendo di usare una richiesta HTTP tipica anziché il payload della richiesta del gestore personalizzato.

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

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

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

Eseguire la funzione in locale

È possibile eseguire questo progetto nel computer di sviluppo locale prima di eseguire la pubblicazione in Azure.

1. Nel terminale integrato avviare l'app per le funzioni usando Azure Functions Core Tools.

   func start
   

2. Con Core Tools in esecuzione, passare all'URL seguente per eseguire una richiesta GET, che include la stringa di query ?name=Functions.

   http://localhost:7071/api/HttpExample?name=Functions

3. Viene restituita una risposta simile alla seguente in un browser:

   

4. Le informazioni sulla richiesta sono visualizzate nel pannello Terminale.

   

5. Premere CTRL+C per arrestare Core Tools.

Dopo aver verificato la corretta esecuzione della funzione nel computer locale, è possibile usare Visual Studio Code per pubblicare il progetto direttamente in Azure.

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.

Compilare il gestore personalizzato per Azure

In questa sezione si pubblica il progetto in Azure in un'app per le funzioni che esegue Linux. Nella maggior parte dei casi, è necessario ricompilare il file binario e modificare la configurazione in modo che corrisponda alla piattaforma di destinazione prima di pubblicarla in Azure.

Go

1. Nel terminale integrato compilare il gestore in Linux/x64. Viene creato un file binario denominato handler nella radice dell'app per le funzioni.

   macOS

   GOOS=linux GOARCH=amd64 go build handler.go
   

   Linux

   GOOS=linux GOARCH=amd64 go build handler.go
   

   Windows

   set GOOS=linux
   set GOARCH=amd64
   go build handler.go
   

   Modificare defaultExecutablePath in host.json da handler.exe a handler. Indica all'app per le funzioni di eseguire il file binario Linux.

Rust

1. Creare un file in .cargo/config. Aggiungere il contenuto seguente e salvare il file.

   [target.x86_64-unknown-linux-musl]
   linker = "rust-lld"
   

2. Nel terminale integrato compilare il gestore in Linux/x64. Viene creato un file binario denominato handler. Copiarlo nella radice dell'app per le funzioni.

   rustup target add x86_64-unknown-linux-musl
   cargo build --release --target=x86_64-unknown-linux-musl
   cp target/x86_64-unknown-linux-musl/release/handler .
   

3. Se si usa Windows, modificare defaultExecutablePath in host.json da handler.exe a handler. Indica all'app per le funzioni di eseguire il file binario Linux.

4. Aggiungere la riga seguente al file con estensione funcignore:

   target
   

   Ciò impedisce la pubblicazione del contenuto della cartella di destinazione.

Creare l'app per le funzioni in Azure

In questa sezione vengono create un'app per le funzioni e le risorse correlate nella sottoscrizione di Azure.

1. Scegliere l'icona di Azure nella barra attività. Nell'area Risorse selezionare quindi l'icona + e scegliere l'opzione Crea app per le funzioni in Azure.

   

2. Quando richiesto, immettere le informazioni seguenti:

   Richiesta	Selezione
   Selezionare la sottoscrizione	scegliere la sottoscrizione da usare. Non verrà visualizzata quando è visibile una sola sottoscrizione in Risorse.
   Immettere un nome univoco a livello globale per l'app per le funzioni	digitare un nome valido in un percorso URL. Il nome digitato viene convalidato per assicurarsi che sia univoco in Funzioni di Azure.
   Selezionare uno stack di runtime	Scegliere Gestore personalizzato.
   Selezionare una località per le nuove risorse	per prestazioni ottimali, scegliere un'area vicina.

   L'estensione mostra lo stato delle singole risorse durante la creazione in Azure nel pannello Azure: Log attività.

   

3. Al termine della creazione, nella sottoscrizione vengono create le risorse di Azure seguenti. Le risorse sono denominate in base al nome dell'app per le funzioni:

   • Un gruppo di risorse, ovvero un contenitore logico di risorse correlate.
   • Un account di Archiviazione di Azure standard, che mantiene lo stato e altre informazioni sul progetto.
   • Un'app per le funzioni, che fornisce l'ambiente per l'esecuzione del codice della funzione. Un'app per le funzioni consente di raggruppare le funzioni come un'unità logica per semplificare la gestione, la distribuzione e la condivisione delle risorse all'interno dello stesso piano di hosting.
   • Un piano di Servizio app di Azure, che definisce l'host sottostante per l'app per le funzioni.
   • Istanza di Application Insights connessa all'app per le funzioni e che tiene traccia dell'uso delle funzioni nell'app.

   Dopo la creazione dell'app per le funzioni e dopo l'applicazione del pacchetto di distribuzione viene visualizzata una notifica.

   Suggerimento

   Per impostazione predefinita, le risorse di Azure richieste dall'app per le funzioni vengono create in base al nome immesso per l'app per le funzioni. Per impostazione predefinita, le risorse vengono create con l'app per le funzioni nello stesso gruppo di risorse. Per personalizzare i nomi delle risorse associate o riutilizzare le risorse esistenti, pubblicare il progetto con le opzioni di creazione avanzate.

Distribuire il progetto in Azure

Importante

La distribuzione in un'app per le funzioni esistente sovrascrive sempre il contenuto di tale app in Azure.

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.

   

Eseguire la funzione in Azure

1. Premere F1 per visualizzare il riquadro comandi, quindi cercare ed eseguire il comando Azure Functions:Execute Function Now.... Se richiesto, selezionare la propria sottoscrizione.

2. Selezionare la nuova risorsa app per le funzioni e HttpExample come funzione.

3. In Immettere il corpo della richiesta digitare { "name": "Azure" }, quindi premere INVIO per inviare questo messaggio di richiesta alla funzione.

4. Quando la funzione viene eseguita in Azure, la risposta viene visualizzata nell'area di notifica. Espandere la notifica per esaminare la risposta completa.

Pulire le risorse

Per continuare con il passaggio successivo e aggiungere alla funzione un'associazione alla coda di Archiviazione di Azure, sarà necessario mantenere tutte le risorse esistenti per poterle riutilizzare.

In caso contrario, seguire questa procedura per eliminare l'app per le funzioni e le risorse correlate per evitare l'addebito di costi aggiuntivi.

1. In Visual Studio Code premere F1 per aprire il riquadro comandi. Nel riquadro comandi cercare e selezionare Azure: Open in portal.

2. Scegliere l'app per le funzioni e premere INVIO. La pagina dell'app per le funzioni viene aperta nel portale di Azure.

3. Nella scheda Panoramica selezionare il collegamento accanto a Gruppo di risorse.

   

4. Nella pagina Gruppo di risorse esaminare l'elenco delle risorse incluse e verificare che siano quelle da eliminare.

5. Selezionare Elimina gruppo di risorse e seguire le istruzioni.

   L'eliminazione potrebbe richiedere alcuni minuti. Al termine, viene visualizzata una notifica per pochi secondi. È anche possibile selezionare l'icona a forma di campana nella parte superiore della pagina per visualizzare la notifica.

Per altre informazioni sui costi di Funzioni di Azure, vedere Stima dei costi del piano a consumo.

Passaggi successivi

Informazioni sui gestori personalizzati di Funzioni di Azure