Application web

5 minutes

Pour utiliser un gestionnaire personnalisé, vous devez créer une application web. Une fois que vous avez écrit votre application et que vous l’avez compilée, vous devez configurer l’hôte Azure Functions pour qu’il sache comment l’utiliser. Nous approfondirons ce sujet plus tard. Tout d’abord, comment créer une application web dans Go ?

Créer une API REST dans Go

Pour créer une API REST à l’aide de Go, vous devez savoir faire un certain nombre de choses :

Importer des bibliothèques. Vous utiliserez les bibliothèques fmt, log et net/http. Ces bibliothèques vous aident à gérer les itinéraires, à traiter les requêtes entrantes et à effectuer la journalisation. Utilisez l’instruction d’importation suivante :
```
import (
   "fmt",
   "log",
   "net/http"
)    
```
Configuration du routage. Les API REST consistent en des divisions logiques appelées itinéraires. Les itinéraires sont des adresses qui répondent à un problème spécifique dans l’application. Pour configurer un itinéraire, appelez la méthode HandleFunc() sur l’instance http et définissez l’itinéraire pour répondre aux requêtes :
```
http.HandleFunc("/", handleRoute)   
```
Dans ce cas, vous devez créer une fonction handleRoute pour faire correspondre les requêtes entrantes à l’itinéraire "/".
Gérer les requêtes. Vous devez gérer les requêtes entrantes et lire des éléments tels que les paramètres de routeur ou de requête ou un corps publié. Vous devez ensuite construire une réponse. Une fonction qui gère une requête peut se présenter comme suit :
```
func handleRequest(w: http:ResponseWriter, r: http.Request) {
    fmt.Fprintf(w, "My first REST API") 
}
```
Le code envoie le texte « Ma première API REST » à un client appelant. La méthode Fprintf() accepte deux arguments : le flux de réponse et la chaîne à renvoyer.
Créer le serveur. Pour être en mesure d’écouter les requêtes, vous devez démarrer le serveur. Vous devez également spécifier une partie à laquelle les requêtes peuvent être envoyées. Le code suivant montre comment créer le serveur :
```
http.ListenAndServe(":3000", nil)
```
Le serveur est maintenant opérationnel et peut écouter les requêtes sur le port 3000.

Créer une application de fonction Azure

Avant de développer une application Azure Functions, nous vous recommandons d’effectuer ce qui suit :

Installez Visual Studio Code. Vous pouvez créer des applications Azure Functions avec un éditeur de texte ou un IDE. Ce module présente certaines extensions qui facilitent la création.
Installez l’extension Visual Studio Code pour Azure Functions. Cette extension vous permet de générer automatiquement un modèle pour une application de fonction, de l’exécuter et de la déboguer.
Installez Azure Functions Core Tools. Cette installation comprend une commande exécutable func qui vous permet d’exécuter votre application de fonction, entre autres choses.

Structurer une application de fonction à l’aide de Visual Studio Code

Une fois que toutes les dépendances nécessaires sont installées sur votre système, l’étape suivante consiste à structurer une application. Quand vous êtes invité à utiliser le runtime, choisissez Gestionnaire personnalisé.

Maintenant, vous avez vérifié que les bons fichiers seront générés. Lorsque vous générez un projet de cette manière, vous devez sélectionner un type de déclencheur pour votre première fonction. Les gestionnaires personnalisés fonctionnent avec les déclencheurs et liaisons habituels.

Une fois que vous avez terminé de générer le projet, vous devez disposer d’une application avec les fichiers suivants :

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

Le fichier function.json se trouve dans un répertoire dont le nom correspond au nom de votre première fonction. Vous utiliserez ce fichier pour configurer votre fonction.

Configurer le projet

Pour que votre application fonctionne avec des primitives HTTP, vous devez configurer quelques éléments :

Écouter un port de gestionnaire personnalisé. Votre application doit écouter un port spécifique. La variable FUNCTIONS_CUSTOMHANDLER_PORT contient la valeur dont vous avez besoin. Vous pouvez rechercher la valeur de port à l’aide du code suivant :
```
customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
```
Configurez le chemin d’accès de l’exécutable par défaut. Étant donné que vous créez un fichier exécutable, vous devez indiquer à votre projet d’application de fonction où il se trouve.

Localisez le fichier function.json à la racine du projet. Dans la section customHandler, spécifiez defaultExecutablePath. Voici un exemple de ce à quoi cela peut ressembler :
```
"customHandler": {
   "defaultExecutablePath": "mygoapp.exe"
}
```
Activez le transfert des requêtes. Lorsque vous utilisez une fonction qui utilise un déclencheur HTTP, vous devez configurer l’application légèrement différemment que si vous traitiez un autre type de déclencheur (comme un déclencheur de file d’attente).

Activez une propriété appelée enableForwardingHttpRequest. Lorsque cette propriété est activée, elle modifie le comportement de traitement des requêtes des manières suivantes :
- Copie de la requête d’origine. La requête HTTP ne contient pas la charge utile de requête du gestionnaire personnalisé. Au lieu de cela, l’hôte Functions appelle le gestionnaire à partir d’une copie de la requête HTTP d’origine.
- Même chemin d’accès que la requête d’origine. L’hôte Functions invoque le gestionnaire avec le même chemin que la requête initiale.
  
  Lorsque vous définissez un itinéraire et un gestionnaire de routage, vous devez être précis dans la manière dont vous configurez le routage. Supposons que vous avez le plan de projet suivant :
```
hello/
  function.json   
```
  Les fichiers dans le plan sont mappés à un itinéraire /api/hello par défaut. Dans votre code pour configurer l’itinéraire, vous devez spécifier l’itinéraire complet :
```
mux.HandleFunc("/api/hello", helloHandler)
```
  Si vous n’avez pas activé ce paramètre pour les autres types de déclencheurs et liaisons, le fait de spécifier le code d’itinéraire comme "/hello" est suffisant.
- Copiez la réponse du gestionnaire. L’hôte Functions retourne une copie de la réponse HTTP du gestionnaire comme réponse à la demande d’origine.

Dans l’exemple précédent, le fichier exécutable est mygoapp.exe. L’exemple suppose que vous êtes en train de créer le fichier exécutable à partir d’un fichier appelé mygoapp.go, mais vous pouvez nommer votre fichier Go comme vous le souhaitez. Sur Linux ou macOS, le fichier exécutable n’a pas d’extension.

Générer l’application

La création de l’application web à ce stade n’est pas très différente de la création d’une application web à l’aide de Go. Pour peu que vous ayez effectué la configuration décrite dans la section précédente, tout doit être prêt.

Maintenant, vous devez effectuer les étapes suivantes :

Lisez le port.
Instanciez une instance de serveur HTTP.
Définissez des itinéraires et des gestionnaires de routage.
Commencez à écouter sur le port.