Exercice - Utiliser un gestionnaire personnalisé pour générer une application

3 minutes

Dans cet exercice, vous allez créer et exécuter une application serverless à l’aide de Go.

Structurer l’application

Commencez par générer la structure de l’application, à l’aide de l’extension Azure Functions dans Visual Studio Code.

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 hello.
Sélectionnez un niveau d’autorisation anonyme. Vous pourrez le changer ultérieurement si vous le souhaitez.

Maintenant, vous avez un projet qui ressemble à quelque chose comme ceci :

hello/
  function.json
.funcignore
.gitignore
host.json
local.settings.json
proxies.json

Créer l’application

La prochaine série d’étapes concerne la création d’une application qui peut répondre à un déclencheur HTTP.

Créez un fichier nommé server.go à la racine du projet.
Donnez à server.go le contenu suivant :
```
package main

import (
 "fmt"
 "io"
 "log"
 "net/http"
 "os"
)
```
Le code précédent importe toutes les bibliothèques dont vous avez besoin pour générer une application HTTP et rechercher les variables d’environnement.
Ajoutez le code suivant après les instructions import :
```
func main() {
  customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
  if !exists {
    customHandlerPort = "8080"
  }
  mux := http.NewServeMux()
  // mux.HandleFunc("/api/hello", helloHandler)
  fmt.Println("Go server Listening on: ", customHandlerPort)
  log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux))
}
```
La fonction main() est appelée par elle-même. La première ligne du code indique comment il lit à partir de la variable d’environnement FUNCTIONS_CUSTOM_HANDLER_PORT :
```
customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
```
Ensuite, la fonction vérifie si le port existe. Si ce n’est pas le cas, la fonction se voit attribuer le port 8080 :
```
if !exists {
  customHandlerPort = "8080"
}
```
Le code suivant instancie une instance de serveur HTTP :
```
mux := http.NewServeMux()
```
La dernière ligne d’importance est celle qui commence à écouter un port spécifique et signale qu’elle est prête à recevoir des requêtes, avec la méthode ListenAndServe() :
```
log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux))
```
Nous allons ajouter le code restant. Tout d’abord, recherchez la ligne suivante et supprimez les marques de commentaire :
```
// mux.HandleFunc("/api/hello", helloHandler)
```

Entre les instructions import et la fonction main(), ajoutez le code suivant :

func helloHandler(w http.ResponseWriter, r *http.Request) {
  w.Header().Set("Content-Type", "application/json")
  if r.Method == "GET" {
    w.Write([]byte("hello world"))
  } else {
    body, _ := io.ReadAll(r.Body)
    w.Write(body)
  }
}

La fonction helloHandler() définit le type de contenu sur application/json. Elle répond avec « hello world » ou le corps publié, le cas échéant.

Exécuter l’application

Vous avez terminé la création du code à ce stade, mais vous devez effectuer quelques réglages pour que ce scénario fonctionne. Vous devez indiquer l’emplacement de votre fichier exécutable, afin que l’hôte de la fonction puisse le trouver. Vous devez également configurer le routage et indiquer que cette application gère les déclencheurs HTTP et aucun autre type de liaison.

À partir d’un terminal, exécutez go build server.go à la racine du projet :
```
go build server.go
```
Cette étape crée un fichier exécutable appelé server sur macOS et Linux, ou server.exe sur Windows.
Ouvrez le fichier host.json et recherchez l’élément defaultExecutablePath à l’intérieur de customHandler. Spécifiez ./server sur macOS et Linux, ou .\\server.exe sur Windows.
Sous l’élément customHandler, ajoutez l’élément enableForwardingHttpRequest et attribuez-lui la valeur true. Votre élément customHandler doit alors se présenter comme ceci :
```
"customHandler": {
 "description": {
   "defaultExecutablePath": "./server",
   "workingDirectory": "",
   "arguments": []
 },
 "enableForwardingHttpRequest" : true
}
```
À partir d’un terminal, exécutez func start à la racine du projet. Vous démarrez ainsi votre application Functions.
```
func start
```
À la fin de la sortie, vous verrez une sortie semblable à celle-ci :
```
Functions:

     hello: [GET,POST] http://localhost:7071/api/hello
```
Dans un navigateur, accédez à http://localhost:7071/api/hello. La sortie suivante doit s’afficher : « hello world ».

Félicitations ! Vous avez développé une application serverless en Go.

Commentaires

Cette page a-t-elle été utile ?