Esercizio - Gestire un messaggio della coda

5 minuti

In questo esercizio si estenderà l'applicazione con una route che può essere attivata su un messaggio presente in una coda.

Nota

Prima di iniziare questo esercizio, assicurarsi di aver scaricato l'estensione Azurite, Azure Storage Explorer e Azure Functions Core Tools.

Eseguire lo scaffolding dell'app

Per questo esercizio si inizierà con una nuova app di Funzioni di Azure. Creare una nuova directory e spostarsi in tale directory.

Selezionare Visualizza>Riquadro comandi.
Selezionare Azure Functions: Create New Project (Q#: Crea nuovo progetto).
Selezionare una cartella, in genere la cartella corrente.
In Selezionare un linguaggio specificare Gestore personalizzato.
In Selezionare un modello per la prima funzione specificare HttpTrigger.
Assegnare un nome all'app, ad esempio queueTrigger.
Selezionare un livello di autorizzazione anonimo. È possibile modificare questa impostazione in un secondo momento, se necessario.

Nella radice creare un file denominato server.go. Il progetto dovrebbe ora includere i file seguenti:

queueTrigger/
  function.json
.funcignore
.gitignore
host.json
local.settings.json
proxies.json
server.go

Passare al file function.json nella directory queueTrigger. Trovare la prima voce di associazione nell'elemento type:
```
{
   "authLevel": "anonymous",
   "type": "httpTrigger",
   "direction": "in",
   "name": "req",
   "methods": [
     "get",
     "post"
   ]
 }
```
Modificare la voce di associazione in questa configurazione:
```
{
   "name": "queueItem",
   "type": "queueTrigger",
   "direction": "in",
   "queueName" : "items",
   "connection": "AzureWebJobsStorage"
}
```
In questo passaggio impostare la proprietà name, a cui si farà riferimento in seguito nel codice. È stato anche modificato il tipo di trigger in queueTrigger, in modo da restare in ascolto dei messaggi della coda.

Il valore queueName fa riferimento a una coda specifica. Quando si eseguirà l'emulatore in un secondo momento, si creerà una coda con tale nome.

Si è infine specificata una variabile in local.settings.json che conterrà la stringa di connessione alla coda.

Creare l'app

A questo punto, si ha una struttura dell'app. Si può quindi aggiungere codice in grado di gestire i messaggi della coda in ingresso.

Aprire il file server.go e aggiungere il codice seguente:

package main

import (
  "encoding/json",
  "fmt"
  "io/ioutil"
  "log"
  "net/http"
  "os"
)

func queueHandler(w http.ResponseWriter, r *http.Request) {
}

func main() {
  customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
  if !exists {
    customHandlerPort = "8080"
  }
  mux := http.NewServeMux()
  mux.HandleFunc("/queueTrigger", queueHandler)
  fmt.Println("Go server Listening on: ", customHandlerPort)
  log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux))
}

È ora configurata una route in /queueTrigger.

Trovare la sezione relativa all'importazione in cui aggiungere gli struct seguenti:

type InvokeRequest struct {
  Data     map[string]json.RawMessage
  Metadata map[string]interface{}
}

Trovare il metodo queueHandler() e aggiungerlo nel modo seguente:

func queueHandler(w http.ResponseWriter, r *http.Request) {
  var invokeRequest InvokeRequest

  d := json.NewDecoder(r.Body)
  d.Decode(&invokeRequest)

  var parsedMessage string
  json.Unmarshal(invokeRequest.Data["queueItem"], &parsedMessage)
}

Il codice legge prima il corpo dal flusso di risposta in ingresso e lo decodifica:

var invokeRequest InvokeRequest

d := json.NewDecoder(r.Body)
d.Decode(&invokeRequest)

Il messaggio stesso viene quindi estratto con una chiamata a Unmarshal():

var parsedMessage string
json.Unmarshal(invokeRequest.Data["queueItem"], &parsedMessage)

Ora che il messaggio è disponibile, è possibile stamparlo.

Aggiungere il codice seguente:
```
fmt.Println(parsedMessage) // your message
```
Il codice è ora completato, ma è necessario configurare il progetto per poterlo testare.
Nel file host.json trovare l'elemento defaultExecutablePath e assegnargli il valore ./server.

Nota

Per Windows, si userà il valore .\server.exe.
Compilare il file server.go eseguendo go build nella radice del progetto:
```
go build server.go
```

Configurare l'ambiente

Il passaggio successivo consiste nel configurare l'ambiente. Poiché si sviluppa il codice in locale, è necessario configurare l'ambiente in modo da poter parlare con una coda di messaggi emulata.

Nel file local.settings.json trovare un elemento in Values denominato AzureWebJobsStorage (o aggiungerlo se mancante). Assegnargli il valore UseDevelopmentStorage=true. La voce JSON dovrebbe essere simile alla seguente:
```
"AzureWebJobsStorage" : "UseDevelopmentStorage=true"
```
Avviare l'estensione Azurite aprendo il riquadro comandi (Visualizza>Riquadro comandi) e quindi selezionando Azurite: Start Queue Service.

Nota

Con questo passaggio verranno creati alcuni file locali nel progetto.
Aprire Azure Storage Explorer. Sul lato sinistro è visibile il contenuto dell'emulatore.
Fare clic con il pulsante destro del mouse sul nodo Queues e selezionare l'opzione per creare una nuova coda. Assegnare alla coda il nome items.

Nota

È possibile assegnare alla coda il nome desiderato. Si sta tuttavia per configurare il file function.json. Qualunque sia il nome qui specificato per la coda, il nome del file deve essere function.json.
Individuare function.json nella directory queueTrigger. Verificare che per la matrice bindings sia specificato quanto segue:
```
{
   "name": "queueItem",
   "type": "queueTrigger",
   "direction": "in",
   "queueName" : "items",
   "connection": "AzureWebJobsStorage"
 }
```
La proprietà queueName ha lo stesso nome della coda creata in Azure Storage Explorer. La proprietà connection punta al valore configurato in local.settings.json.

La proprietà name ha il valore queueItem, che viene usato dal codice Go per analizzare il messaggio della coda.

Eseguire l'app

A questo punto, la configurazione è completata. Non si deve fare altro che eseguire l'app, avviare Azure Storage Explorer e creare un messaggio della coda. Il codice deve essere in grado di utilizzare tale messaggio.

Da un terminale eseguire il comando func start nella radice del progetto:
```
func start
```
In Visual Studio Code aprire il riquadro comandi ed eseguire Azurite: Start Queue Service.
Avviare Azure Storage Explorer, se non è già stato avviato.
In Azure Storage Explorer selezionare Aggiungi messaggio:
Nella finestra di dialogo visualizzata immettere message e selezionare OK. Vengono visualizzati i dettagli del messaggio creato.
In Visual Studio Code la funzione dovrebbe essere in esecuzione. Nel terminale sarà visualizzato il testo message come ultima riga.

La funzione è riuscita a utilizzare il messaggio della coda e a scriverne il contenuto.

Complimenti. È stata creata una funzione di Azure in Go che può essere attivata in base a un messaggio della coda. È stato inoltre analizzato il messaggio.

La scelta dell'operazione da eseguire con un messaggio in ingresso spetta allo sviluppatore. È ad esempio possibile archiviarlo in un database o inviarlo come payload in una richiesta Web.

Esercizio - Gestire un messaggio della coda

Eseguire lo scaffolding dell'app

Creare l'app

Configurare l'ambiente

Eseguire l'app

Commenti e suggerimenti