{"id":30782,"date":"2019-10-31T21:37:25","date_gmt":"2019-10-31T18:37:25","guid":{"rendered":"https:\/\/prohoster.info\/blog\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu\/"},"modified":"2019-10-31T21:37:25","modified_gmt":"2019-10-31T18:37:25","slug":"razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","status":"publish","type":"post","link":"https:\/\/prohoster.info\/fr\/blog\/news\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","title":{"rendered":"D\u00e9veloppement de serveurs web en Golang \u2014 de simple \u00e0 complexe","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"D\u00e9veloppement
\n
\nIl y a cinq ans, j'ai commenc\u00e9 \u00e0 d\u00e9velopper Gophish<\/a><\/noindex>, ce qui m'a permis d'explorer Golang. J'ai r\u00e9alis\u00e9 que Go est un langage puissant, dont les possibilit\u00e9s sont compl\u00e9t\u00e9es par de nombreuses biblioth\u00e8ques. Go est polyvalent : en particulier, il permet de d\u00e9velopper sans probl\u00e8me des applications serveur.<\/p>\n

Cet article est consacr\u00e9 \u00e0 l'\u00e9criture d'un serveur en Go. Nous commencerons par des choses simples, comme \u00ab Bonjour monde ! \u00bb, et nous finirons avec une application ayant les fonctionnalit\u00e9s suivantes :<\/p>\n

\u2014 Utilisation de Let\u2019s Encrypt pour HTTPS.
\n\u2014 Fonctionnement en tant que routeur API.
\n\u2014 Gestion de middleware.
\n\u2014 Traitement de fichiers statiques.
\n\u2014 Arr\u00eat propre.
\n<\/a><\/noindex><\/p>\n

Skillbox recommande :<\/b> Cours pratique \u00ab D\u00e9veloppeur Python depuis z\u00e9ro \u00bb<\/a><\/noindex>.<\/p>\n

Rappelons-le :<\/b> pour tous les lecteurs de \u00ab Habr \u00bb \u2014 une r\u00e9duction de 10 000 roubles lors de l'inscription \u00e0 tout cours Skillbox avec le code promo \u00ab Habr \u00bb.<\/i>\n<\/p><\/blockquote>\n

Hello, world!<\/h3>\n

\nCr\u00e9er un serveur web en Go peut se faire tr\u00e8s rapidement. Voici un exemple d'utilisation d'un gestionnaire qui renvoie le fameux \u00ab Hello, world ! \u00bb mentionn\u00e9 ci-dessus.<\/p>\n

package main\n \nimport (\n\"fmt\"\n\"net\/http\"\n)\n \nfunc main() {\nhttp.HandleFunc(\"\/\", func(w http.ResponseWriter, r *http.Request) {\nfmt.Fprintf(w, \"Hello World!\")\n})\nhttp.ListenAndServe(\":80\", nil)\n}<\/code><\/pre>\n
\nApr\u00e8s cela, si vous lancez l'application et ouvrez la page localhost<\/noindex>, vous verrez imm\u00e9diatement le texte \u00ab Hello, world ! \u00bb (bien s\u00fbr, si tout fonctionne correctement).<\/p>\n
Ensuite, nous utiliserons \u00e0 plusieurs reprises le gestionnaire, mais d'abord, comprenons comment tout cela fonctionne.<\/p>\n
net\/http<\/h4>\n
\nL'exemple utilise le paquet net\/http<\/code><\/a><\/noindex>, qui est l'outil principal en Go pour le d\u00e9veloppement aussi bien de serveurs que de clients HTTP. Pour comprendre le code, examinons le sens de trois \u00e9l\u00e9ments importants : http.Handler, http.ServeMux et http.Server.<\/p>\n
Les gestionnaires HTTP<\/h4>\n
\nLorsque nous recevons une requ\u00eate, le gestionnaire l'analyse et forme une r\u00e9ponse. Les gestionnaires en Go sont impl\u00e9ment\u00e9s de la mani\u00e8re suivante :<\/p>\n
type Handler interface {\n        ServeHTTP(ResponseWriter, *Request)\n}<\/code><\/pre>\n
\nDans le premier exemple, nous utilisons la fonction d'assistance http.HandleFunc. Elle enveloppe une autre fonction qui, \u00e0 son tour, prend http.ResponseWriter et http.Request dans ServeHTTP.<\/p>\n
En d'autres termes, les gestionnaires en Golang sont repr\u00e9sent\u00e9s par une interface unique, ce qui offre de nombreuses possibilit\u00e9s au programmeur. Par exemple, le middleware est impl\u00e9ment\u00e9 \u00e0 l'aide d'un gestionnaire o\u00f9 ServeHTTP fait d'abord quelque chose, puis appelle la m\u00e9thode ServeHTTP d'un autre gestionnaire.<\/p>\n
Comme mentionn\u00e9 pr\u00e9c\u00e9demment, les gestionnaires ne font que former des r\u00e9ponses aux requ\u00eates. Mais quel gestionnaire faut-il utiliser \u00e0 un moment donn\u00e9 ?<\/p>\n
Routage des requ\u00eates<\/h4>\n
\nPour faire le bon choix, utilisez un multiplexeur HTTP. Dans plusieurs biblioth\u00e8ques, il est appel\u00e9 muxer ou router, mais tout cela revient au m\u00eame. La fonction du multiplexeur consiste \u00e0 analyser le chemin de la requ\u00eate et \u00e0 choisir le gestionnaire appropri\u00e9.<\/p>\n
Si vous avez besoin d'un support pour un routage complexe, il est pr\u00e9f\u00e9rable d'utiliser des biblioth\u00e8ques tierces. Parmi les plus avanc\u00e9es, on trouve gorilla\/mux<\/a><\/noindex> et go-chi\/chi<\/a><\/noindex>, ces biblioth\u00e8ques permettent d'impl\u00e9menter un traitement interm\u00e9diaire sans trop de probl\u00e8mes. Gr\u00e2ce \u00e0 elles, vous pouvez configurer le routage wildcard et accomplir plusieurs autres t\u00e2ches. Leur avantage est la compatibilit\u00e9 avec les gestionnaires HTTP standards. En cons\u00e9quence, vous pouvez \u00e9crire un code simple avec la possibilit\u00e9 de le modifier \u00e0 l'avenir.<\/p>\n
Travailler avec des frameworks complexes dans des situations normales n\u00e9cessitera des solutions non standard, ce qui complique consid\u00e9rablement l'utilisation des gestionnaires par d\u00e9faut. Pour cr\u00e9er la majorit\u00e9 des applications, une combinaison de la biblioth\u00e8que par d\u00e9faut et d'un routeur simple suffira.<\/p>\n
Traitement des requ\u00eates<\/h4>\n
\nDe plus, nous avons besoin d'un composant qui va \u00ab \u00e9couter \u00bb les connexions entrantes et rediriger toutes les requ\u00eates vers le bon gestionnaire. Cette t\u00e2che est facilement g\u00e9r\u00e9e par http.Server.<\/p>\n
Ci-dessous, il est montr\u00e9 que le serveur est responsable de toutes les t\u00e2ches relatives au traitement des connexions. Cela inclut, par exemple, le fonctionnement avec le protocole TLS. Pour impl\u00e9menter l'appel http.ListenAndServer, nous utilisons le serveur HTTP standard.<\/p>\n
Examinons maintenant des exemples plus complexes.<\/p>\n
Ajouter Let\u2019s Encrypt<\/h3>\n
\nPar d\u00e9faut, notre application fonctionne avec le protocole HTTP, mais il est recommand\u00e9 d'utiliser le protocole HTTPS. En Go, cela peut se faire sans probl\u00e8me. Si vous avez obtenu un certificat et une cl\u00e9 priv\u00e9e, il suffit d'appeler ListenAndServeTLS en indiquant les bons fichiers de certificat et de cl\u00e9.<\/p>\n
http.ListenAndServeTLS(\":443\", \"cert.pem\", \"key.pem\", nil)<\/code><\/pre>\n
\nOn peut toujours faire mieux.<\/p>\n
Let's Encrypt<\/a><\/noindex> fournit des certificats gratuits avec la possibilit\u00e9 de mise \u00e0 jour automatique. Pour utiliser le service, vous avez besoin du paquet autocert<\/code>.<\/p>\n
Le moyen le plus simple de le configurer est d\u2019utiliser la m\u00e9thode autocert.NewListener en combinaison avec http.Serve. La m\u00e9thode permet d\u2019obtenir et de mettre \u00e0 jour des certificats TLS, tandis que le serveur HTTP traite les requ\u00eates :<\/p>\n
http.Serve(autocert.NewListener(\"example.com\"), nil)<\/code><\/pre>\n
\nSi nous ouvrons dans le navigateur example.com<\/a><\/noindex>, nous obtiendrons la r\u00e9ponse HTTPS \u00ab Hello, world! \u00bb.<\/p>\n
Si vous avez besoin d'une configuration plus minutieuse, il vaut mieux utiliser le gestionnaire autocert.Manager. Ensuite, nous cr\u00e9ons notre propre instance http.Server (jusqu'\u00e0 pr\u00e9sent, nous l'avons utilis\u00e9e par d\u00e9faut) et ajoutons le gestionnaire dans la configuration TLS du serveur :<\/p>\n
m := &autocert.Manager{\nCache:      autocert.DirCache(\"golang-autocert\"),\nPrompt:     autocert.AcceptTOS,\nHostPolicy: autocert.HostWhitelist(\"example.org\", \"www.example.org\"),\n}\nserver := &http.Server{\n    Addr:      \":443\",\n    TLSConfig: m.TLSConfig(),\n}\nserver.ListenAndServeTLS(\"\", \"\")<\/code><\/pre>\n
\nC'est une m\u00e9thode simple pour mettre en \u0153uvre un support complet de HTTPS avec renouvellement automatique du certificat.<\/p>\n
Ajout de routes personnalis\u00e9es<\/h3>\n
\nLe routeur par d\u00e9faut inclus dans la biblioth\u00e8que standard est bon, mais il est tr\u00e8s simple. La plupart des applications n\u00e9cessitent une routage plus complexe, y compris des routes imbriqu\u00e9es et des routes wildcard ou une proc\u00e9dure d'\u00e9tablissement de motifs et de param\u00e8tres de chemins.<\/p>\n
Dans ce cas, il vaut mieux utiliser les paquets gorilla\/mux<\/a><\/noindex> et go-chi\/chi<\/a><\/noindex>. Avec le dernier, nous apprendrons \u00e0 travailler \u2014 ci-dessous un exemple.<\/p>\n
Donn\u00e9 \u2014 le fichier api\/v1\/api.go, contenant les routes pour notre API :<\/p>\n
\/ HelloResponse is the JSON representation for a customized message\ntype HelloResponse struct {\nMessage string `json:\"message\"`\n}\n \n\/\/ HelloName returns a personalized JSON message\nfunc HelloName(w http.ResponseWriter, r *http.Request) {\nname := chi.URLParam(r, \"name\")\nresponse := HelloResponse{\nMessage: fmt.Sprintf(\"Hello %s!\", name),\n}\njsonResponse(w, response, http.StatusOK)\n}\n \n\/\/ NewRouter returns an HTTP handler that implements the routes for the API\nfunc NewRouter() http.Handler {\nr := chi.NewRouter()\nr.Get(\"\/{name}\", HelloName)\nreturn r\n}<\/code><\/pre>\n
\nNous d\u00e9finissons un pr\u00e9fixe api\/vq pour les routes dans le fichier principal.<\/p>\n
Nous pouvons alors le monter sur notre routeur principal sous le pr\u00e9fixe api\/v1\/ dans notre application principale :<\/p>\n
\/\/ NewRouter returns a new HTTP handler that implements the main server routes\nfunc NewRouter() http.Handler {\nrouter := chi.NewRouter()\n    router.Mount(\"\/api\/v1\/\", v1.NewRouter())\n    return router\n}\nhttp.Serve(autocert.NewListener(\"example.com\"), NewRouter())<\/code><\/pre>\n
\nLa simplicit\u00e9 de traitement des routes complexes en Go permet de simplifier la structuration pour le maintien de grandes applications complexes.<\/p>\n
Travailler avec le middleware<\/h3>\n
\nDans le cas du traitement interm\u00e9diaire, un gestionnaire HTTP est envelopp\u00e9 dans un autre, ce qui permet d'effectuer rapidement l'authentification, la compression, la journalisation et quelques autres fonctions.<\/p>\n
\u00c0 titre d'exemple, consid\u00e9rons l'interface http.Handler, avec laquelle nous allons \u00e9crire un gestionnaire d'authentification des utilisateurs du service.<\/p>\n
func RequireAuthentication(next http.Handler) http.Handler {\n    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n        if !isAuthenticated(r) {\n            http.Redirect(w, r, \"\\\/login\", http.StatusTemporaryRedirect)\n            return\n        }\n        \\\/\\\/ En supposant que l'authentification r\u00e9ussie, ex\u00e9cutez le gestionnaire original\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nIl existe des routeurs tiers, comme chi, qui permettent d'\u00e9largir la fonctionnalit\u00e9 du traitement interm\u00e9diaire.<\/p>\n
Travailler avec des fichiers statiques<\/h3>\n
\nLa biblioth\u00e8que standard de Go inclut des fonctionnalit\u00e9s pour le traitement de contenu statique, y compris des images, ainsi que des fichiers JavaScript et CSS. On peut y acc\u00e9der via la fonction http.FileServer. Elle retourne un gestionnaire qui distribue des fichiers depuis un r\u00e9pertoire sp\u00e9cifique.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Configuration for serving static files\nstaticPath, _ := filepath.Abs(\"..\/..\/static\/\")\nfs := http.FileServer(http.Dir(staticPath))\n    router.Handle(\"\/*\", fs)\n    \n    return r<\/code><\/pre>\n
\nIl est important de se rappeler que http.Dir affiche le contenu du r\u00e9pertoire si le fichier index.html principal n'est pas pr\u00e9sent. Dans ce cas, pour \u00e9viter toute compromission du r\u00e9pertoire, il convient d'utiliser le paquet non index\u00e9<\/code><\/a><\/noindex>.<\/p>\n
Arr\u00eat correct<\/h3>\n
\nEn Go, il existe \u00e9galement une fonction permettant la fermeture correcte d'un serveur HTTP. Cela peut se faire \u00e0 l'aide de la m\u00e9thode Shutdown(). Le serveur fonctionne dans une goroutine, et ensuite, un canal \u00e9coute pour recevoir un signal d'interruption. D\u00e8s que le signal est re\u00e7u, le serveur s'arr\u00eate, mais pas imm\u00e9diatement, apr\u00e8s quelques secondes.<\/p>\n
handler := server.NewRouter()\nsrv := &http.Server{\n    Handler: handler,\n}\n \ngo func() {\nsrv.Serve(autocert.NewListener(domains...))\n}()\n \n\/\/ Attendre un signal d'interruption\nc := make(chan os.Signal, 1)\nsignal.Notify(c, os.Interrupt)\n<-c\n \n\/\/ Essayer un arr\u00eat gracieux\nctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\ndefer cancel()\nsrv.Shutdown(ctx)<\/code><\/pre>\n
<\/p>\n
En conclusion<\/h3>\n
\nGo est un langage puissant avec une biblioth\u00e8que standard presque universelle. Ses capacit\u00e9s par d\u00e9faut sont assez larges, et on peut les renforcer gr\u00e2ce \u00e0 des interfaces \u2014 ce qui permet de d\u00e9velopper des serveurs HTTP vraiment fiables.<\/p>\n
Skillbox recommande :<\/b><\/p>\n