Exercice - Gérer un message de file d’attente

5 minutes

Dans cet exercice, vous allez étendre votre application avec un itinéraire qui peut se déclencher sur un message dans une file d’attente de messages.

Notes

Avant de commencer cet exercice, assurez-vous d’avoir téléchargé l’extension Azurite, l’Explorateur Stockage Azure et Azure Functions Core Tools.

Structurer l’application

Pour cet exercice, nous allons commencer par une nouvelle application Azure Functions. Créez un répertoire et placez-vous dans celui-ci.

Sélectionnez Afficher>Palette de commandes.
Sélectionnez Azure Functions : Créer un projet.
Sélectionnez un dossier, généralement votre dossier actuel.
Dans Sélectionner un langage, sélectionnez Gestionnaire personnalisé.
Dans Sélectionner un modèle pour votre première fonction, sélectionnez HttpTrigger.
Donnez un nom à l’application, par exemple queueTrigger.
Sélectionnez un niveau d’autorisation anonyme. Vous pourrez le changer ultérieurement si vous le souhaitez.

À la racine, créez un fichier nommé server.go. Votre projet doit maintenant avoir les fichiers suivants :

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

Accédez au fichier function.json dans le répertoire queueTrigger. Recherchez la première entrée de liaison dans l’élément type :
```
{
   "authLevel": "anonymous",
   "type": "httpTrigger",
   "direction": "in",
   "name": "req",
   "methods": [
     "get",
     "post"
   ]
 }
```
Remplacez cette entrée de liaison par cette configuration :
```
{
   "name": "queueItem",
   "type": "queueTrigger",
   "direction": "in",
   "queueName" : "items",
   "connection": "AzureWebJobsStorage"
}
```
Dans cette étape, vous définissez la propriété name. Vous en aurez à nouveau besoin ultérieurement dans le code. Vous avez également modifié le type de déclencheur sur queueTrigger, ce qui permet d’écouter les messages de la file d’attente.

La valeur queueName désigne une file d’attente spécifique. Lorsque vous exécutez l’émulateur ultérieurement, vous allez créer une file d’attente avec un nom de ce type.

Enfin, vous avez pointé une variable dans local.settings.json qui contiendra la chaîne de connexion à la file d’attente.

Créer l’application

À ce stade, vous avez un squelette d’application. Vous êtes maintenant prêt à ajouter du code capable de traiter les messages de file d’attente entrants.

Ouvrez le fichier server.go et ajoutez le code suivant :

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))
}

Vous disposez maintenant d’un itinéraire configuré à l’adresse /queueTrigger.

Recherchez la section import et ajoutez-y les struct suivants :

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

Recherchez la méthode queueHandler() et modifiez-la de la façon suivante :

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)
}

Le code lit d’abord le corps à partir du flux de réponse entrant et le décode :

var invokeRequest InvokeRequest

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

Le message lui-même est extrait par un appel à Unmarshal() :

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

Maintenant que vous avez le message, imprimez-le.

Ajoutez le code suivant :
```
fmt.Println(parsedMessage) // your message
```
Votre code est maintenant écrit, mais vous devez configurer votre projet afin de pouvoir le tester.
Dans le fichier host.json, recherchez l’élément defaultExecutablePath et affectez-lui la valeur ./server.

Notes

Pour Windows, vous pouvez utiliser la valeur .\server.exe.
Générez le fichier server.go en exécutant go build à la racine du projet :
```
go build server.go
```

Configurer l’environnement

L’étape suivante consiste à configurer votre environnement. Étant donné que vous effectuez un développement en local, vous devez le configurer pour pouvoir communiquer avec une file d’attente de messages émulée.

Dans le fichier local.settings.json, recherchez un élément dans Values appelé AzureWebJobsStorage (ou ajoutez-le s’il est manquant). Donnez-lui la valeur UseDevelopmentStorage=true. Votre entrée JSON devrait ressembler à ceci :
```
"AzureWebJobsStorage" : "UseDevelopmentStorage=true"
```
Démarrez l’extension Azurite en ouvrant la palette de commandes (Affichage>Palette de commandes), puis en sélectionnant Azurite : Démarrer le service de file d’attente.

Notes

Cette étape permet de créer des fichiers locaux dans votre projet.
Ouvrez l’Explorateur de stockage Azure. Sur le côté gauche, le contenu de l’émulateur est visible.
Cliquez avec le bouton droit sur le nœud Files d’attente, puis sélectionnez l’option permettant de créer une nouvelle file d’attente. Donnez-lui le nom items.

Notes

Vous pouvez nommer la file d’attente comme vous le souhaitez. Toutefois, vous êtes sur le point de configurer votre fichier function.json. Le nom de la file d’attente doit être placé dans function.json.
Recherchez function.json sous le répertoire queueTrigger. Assurez-vous que le tableau bindings contient l’entrée suivante :
```
{
   "name": "queueItem",
   "type": "queueTrigger",
   "direction": "in",
   "queueName" : "items",
   "connection": "AzureWebJobsStorage"
 }
```
La propriété queueName porte le même nom que la file d’attente que vous avez créée dans l’Explorateur Stockage Azure. La propriété connection pointe sur la valeur que vous avez configurée dans local.settings.json.

La propriété name a la valeur queueItem. Votre code Go utilise cette valeur pour analyser le message de la file d’attente.

Exécuter l’application

À ce stade, tout est en place. Il vous suffit d’exécuter l’application, de démarrer l’Explorateur Stockage Azure et de créer un message de file d’attente. Votre code doit être en mesure de consommer ce message.

À partir d’un terminal, exécutez la commande func start à la racine du projet :
```
func start
```
Dans Visual Studio Code, ouvrez la palette de commandes et exécutez Azurite : Démarrer le service de file d’attente.
Démarrez l’Explorateur Stockage Azure, s’il n’est pas déjà démarré.
Dans l’Explorateur Stockage Azure, sélectionnez Ajouter un message :
Dans la boîte de dialogue qui s’affiche, entrez message, puis sélectionnez OK. Vous voyez maintenant les détails du message que vous avez créé.
Dans Visual Studio Code, votre fonction doit maintenant être en cours d’exécution. Dans le terminal, vous devez maintenant voir message imprimé sur la dernière ligne.

Votre fonction a pu consommer le message de file d’attente et écrire son contenu.

Félicitations ! Vous avez créé une fonction Azure dans Go qui peut se déclencher sur un message de file d’attente. Vous avez également analysé ce message.

Vous pouvez faire ce que vous souhaitez avec un message entrant. Par exemple, vous pouvez le stocker dans une base de données ou l’envoyer en tant que charge utile dans une requête web.

Exercice - Gérer un message de file d’attente

Structurer l’application

Créer l’application

Configurer l’environnement

Exécuter l’application

Commentaires