App Web

5 minuti

Per usare un gestore personalizzato, è necessario creare un'applicazione Web. Dopo aver scritto e compilato l'applicazione, è necessario configurare l'host di Funzioni di Azure in modo che sappia come usarla. Questo argomento verrà approfondito più avanti. Prima di tutto si vedrà come creare un'applicazione Web in Go.

Creare un'API REST in Go

Per creare un'API REST con Go, è necessario sapere come eseguire alcune operazioni:

Importare le librerie. Si useranno le librerie fmt, log e net/http, che consentiranno di gestire le route, le richieste in ingresso e la registrazione. Usare l'istruzione di importazione seguente:
```
import (
   "fmt",
   "log",
   "net/http"
)    
```
Configurare il routing. Le API REST sono costituite da divisioni logiche denominate route. Le route sono indirizzi che rispondono a un problema specifico nell'app. Per configurare una route, chiamare il metodo HandleFunc() sull'istanza http e definire la route per rispondere alle richieste:
```
http.HandleFunc("/", handleRoute)   
```
In questo caso, è necessario creare una funzione handleRoute per associare le richieste in ingresso rispetto alla route "/".
Gestire le richieste. È necessario gestire le richieste in ingresso e leggere dati come i parametri di route o di query o un corpo pubblicato. È quindi necessario creare una risposta. Una funzione che gestisce una richiesta può avere un aspetto simile al seguente:
```
func handleRequest(w: http:ResponseWriter, r: http.Request) {
    fmt.Fprintf(w, "My first REST API") 
}
```
Il codice invia il testo "My first REST API" a un client chiamante. Il metodo Fprintf() accetta due argomenti: il flusso di risposta e la stringa da restituire.
Creare il server. Per poter restare in ascolto delle richieste, è necessario avviare il server. È anche necessario specificare una parte a cui possono essere inviate le richieste. Il codice seguente illustra come creare il server:
```
http.ListenAndServe(":3000", nil)
```
Il server è ora attivo e può restare in ascolto delle richieste sulla porta 3000.

Creare un'app Funzioni di Azure

Prima di sviluppare un'app di Funzioni di Azure, è consigliabile:

Installare Visual Studio Code. È possibile creare app di Funzioni di Azure con qualsiasi editor di testo o IDE. In questo modulo vengono illustrate alcune estensioni che facilitano la creazione di un'app di questo tipo.
Installare l'estensione di Visual Studio Code per Funzioni di Azure. Questa estensione consente di eseguire lo scaffolding di un'app per le funzioni, eseguirla e sottoporla a debug.
Installare Azure Functions Core Tools. Questa installazione include, tra le altre cose, un comando eseguibile func che consente di eseguire l'app per le funzioni.

Eseguire lo scaffolding di un'app per le funzioni tramite Visual Studio Code

Dopo aver installato nel sistema tutte le dipendenze necessarie, il passaggio successivo da eseguire consiste nello scaffolding di un'applicazione. Quando vengono chieste informazioni sul runtime, scegliere Gestore personalizzato.

A questo punto si è certi che verranno generati i file corretti. Quando si genera un progetto in questo modo, è necessario selezionare un tipo di trigger per la prima funzione. I gestori personalizzati funzionano con i consueti trigger e associazioni.

Al termine della generazione del progetto, si dovrebbe avere un'app con i file seguenti:

host.json
local.setting.json
proxies.json
function.json

Il file function.json si trova in una directory il cui nome corrisponde a quello assegnato alla prima funzione. Per configurare la funzione verrà usato questo file.

Configurare il progetto

Per consentire il funzionamento dell'app con le primitive HTTP, è necessario configurare alcuni aspetti:

Restare in ascolto su una porta di gestore personalizzato. L'app deve restare in ascolto su una porta specifica. La variabile FUNCTIONS_CUSTOMHANDLER_PORT contiene il valore necessario. È possibile cercare il valore della porta usando il codice seguente:
```
customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
```
Configurare il percorso eseguibile predefinito. Poiché si sta creando un file eseguibile, è necessario indicare dove si trova il file al progetto di app per le funzioni.

Posizionare il file function.json nella radice del progetto. Nella sezione customHandler specificare defaultExecutablePath. Ecco un esempio dell'aspetto che può avere il codice:
```
"customHandler": {
   "defaultExecutablePath": "mygoapp.exe"
}
```
Abilitare l'inoltro delle richieste. Quando si gestisce una funzione che usa un trigger HTTP, è opportuno configurare l'app in modo leggermente diverso rispetto a un altro tipo di trigger, ad esempio un trigger di accodamento.

Abilitare una proprietà denominata enableForwardingHttpRequest. Quando questa proprietà è abilitata, modifica il comportamento della modalità di gestione della richiesta nei modi seguenti:
- Copia della richiesta originale. La richiesta HTTP non contiene il payload della richiesta del gestore personalizzato. In realtà, l'host di Funzioni richiama il gestore con una copia della richiesta HTTP originale.
- Stesso percorso della richiesta originale. L'host di Funzioni richiama il gestore con lo stesso percorso della richiesta originale.
  
  Quando si definiscono una route e un gestore di route, è necessario specificare come configurare il routing. Si supponga di avere la struttura di progetto seguente:
```
hello/
  function.json   
```
  Per impostazione predefinita, i file nella struttura verranno mappati a una route /api/hello. Nel codice di configurazione della route è necessario specificare la route completa:
```
mux.HandleFunc("/api/hello", helloHandler)
```
  Se questa impostazione non fosse stata abilitata per altri tipi di trigger e associazioni, sarebbe stato sufficiente specificare il codice della route come "/hello".
- Copia della risposta del gestore. L'host di Funzioni restituisce una copia della risposta HTTP del gestore come risposta alla richiesta originale.

Nell'esempio precedente il file eseguibile è mygoapp.exe. L'esempio presuppone che si crei il file eseguibile da un file denominato mygoapp.go, ma è possibile assegnare qualsiasi nome al file Go. In Linux o macOS il file eseguibile non ha un'estensione.

Creare l'app

La procedura per creare l'app Web a questo punto non è molto diversa dalla creazione di un'app Web con Go. Una volta completata la configurazione descritta nella sezione precedente, è tutto pronto.

È ora necessario eseguire i passaggi seguenti:

Leggere la porta.
Creare un'istanza del server HTTP.
Definire route e gestori di route.
Restare in ascolto sulla porta.