Comment déployer une application Web Go à l’aide de Nginx sur Ubuntu 18.04

_L’auteur a sélectionné le Tech Education Fund pour recevoir un don dans le cadre du programme Write for DOnations. _

introduction

Go est un langage de programmation polyvalent qui devient progressivement l’un des langages de programmation Web les plus populaires. En se concentrant sur la simplicité, les concepteurs de Go ont créé un langage facile à apprendre et plus rapide que beaucoup d’autres langages d’applications Web, tirant parti de fonctionnalités efficaces telles que sa capacité à traiter plusieurs demandes à la fois en raison de la simultanéité. De ce fait, le déploiement d’une application Web dans Go sera utile à de nombreux développeurs back-end.

Nginx est l’un des serveurs Web les plus populaires au monde en raison de son faible poids en ressources et de sa fiabilité sous charge. Nombre des sites Internet les plus importants et les plus fréquemment visités dépendent de Nginx pour diffuser leur contenu. Lors du déploiement, Nginx est souvent utilisé comme équilibreur de charge ou proxy inverse pour renforcer la sécurité et rendre l’application plus robuste. En conjonction avec un back-end Web Go, Nginx peut proposer une application Web puissante et rapide.

Dans ce tutoriel, vous allez créer une application Web + Hello World + dans Go et la déployer sur un serveur Ubuntu 18.04 en utilisant Nginx en tant que proxy inverse.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants:

De plus, afin de réaliser un déploiement de niveau production de votre application Web Go, il est important de protéger votre serveur en installant un certificat TLS / SSL. Cette étape est * fortement encouragée *. Pour sécuriser votre application Web Go, suivez Comment sécuriser Nginx avec Let’s Encrypt on Ubuntu 18.04 après * l’étape 3 * de ce tutoriel pour obtenir le certificat gratuit TLS / SSL.

Étape 1 - Construire l’application Web Go

Dans cette étape, vous allez créer un exemple d’application Web Go qui affiche + Hello World en` + `et salue l'utilisateur en ' / greet / +`. Si vous souhaitez en savoir plus sur les bases de la programmation dans Go, consultez notre How To Ecrivez votre premier programme en Go article.

Tout d’abord, créez un nouveau répertoire dans votre répertoire https://www.digitalocean.com/community/tutorials/understanding-the-gopath [+ GOPATH +] pour contenir le fichier source. Vous pouvez nommer le dossier comme bon vous semble, mais ce tutoriel utilisera ++:

mkdir $GOPATH/

Suivre la structure de fichier suggérée dans le didacticiel relatif aux prérequis https://www.digitalocean.com/community/tutorials/how-to-install-go-and-set-up-a-local-programming-environment-on-ubuntu-18 -04 [Comment installer Go et configurer un environnement de programmation local sur Ubuntu 18.04], cela donnera à votre répertoire le chemin «+ ~ / go / go-web +».

Ensuite, lancez ce qui suit pour changer de répertoire dans le dossier que vous venez de créer dans votre + GOPATH +:

cd $GOPATH/go-web

Utilisez + nano + ou votre éditeur de texte préféré pour créer un fichier nommé + main.go +, qui contiendra le code source de votre application Web:

nano main.go

Pour créer les fonctionnalités de l’application + Hello World +, ajoutez le code Go suivant dans le fichier + main.go + nouvellement créé:

~ / go / go-web / main.go

package main

import (
   "fmt"
   "net/http"
)

func main() {
   http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
       fmt.Fprintf(w, "Hello World")
   })

   http.HandleFunc("/greet/", func(w http.ResponseWriter, r *http.Request) {
       name := r.URL.Path[len("/greet/"):]
       fmt.Fprintf(w, "Hello %s\n", name)
   })

   http.ListenAndServe(":9990", nil)
}

Voyons maintenant ce que le fragment de code précédent fera, en commençant par la première ligne.

Tout d’abord, vous avez écrit le point d’entrée dans votre application:

~ / go / go-web / main.go

package main
...

Le paquet + main + indique au compilateur de Go de compiler ce fichier en tant que programme exécutable plutôt qu’en tant que bibliothèque partagée.

Ensuite, vous avez les instructions + import +:

~ / go / go-web / main.go

...

import (
   "fmt"
   "net/http"
)
...

Cet extrait importe les modules nécessaires au fonctionnement de ce code, notamment le package + fmt + standard et le package + net / http + de votre serveur Web.

L’extrait suivant crée votre première route dans la fonction + main +, qui est le point d’entrée de toute application Go:

~ / go / go-web / main.go

...
func main () {
   http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
       fmt.Fprintf(w, "Hello World")
   })
 ...
}
...

Une route parent + / + est créée dans + func main +, qui retournera le texte + Hello World + à la demande.

La seconde route, comme indiqué dans l’extrait suivant, accepte un paramètre d’URL, dans ce cas un nom, à afficher accompagné d’un message d’accueil.

~ / go / go-web / main.go

...
func main () {
 ...
   http.HandleFunc("/greet/", func(w http.ResponseWriter, r *http.Request) {
       name := r.URL.Path[len("/greet/"):]
       fmt.Fprintf(w, "Hello %s\n", name)
   })
...
}
...

Ceci utilise + URL.Path + de Go pour stocker la valeur juste après + / greet / + et la transmettre comme nom à partir du paramètre URL.

Enfin, vous instanciez votre serveur:

~ / go / go-web / main.go

...
func main () {
 ...
 http.ListenAndServe(":9990", nil)
}

Le fragment de code précédent démarre le serveur et expose votre application via le port + 9990 + en utilisant le serveur + http + intégré de Go.

Une fois que vous avez terminé d’examiner le code dans + main.go +, enregistrez le fichier et quittez votre éditeur de texte.

Ensuite, construisez l’exécutable binaire de votre application en lançant:

go build main.go

La commande précédente compilera + main.go + pour produire un exécutable intitulé + main +.

Vous avez créé votre exemple d’application Web Go. Ensuite, vous allez créer un fichier unité systemd pour que votre application continue de fonctionner en arrière-plan, même lorsque vous n’accédez pas à votre serveur.

Étape 2 - Création d’un fichier unité Systemd

Dans cette étape, vous allez créer un fichier d’unité systemd pour que votre application continue de fonctionner en arrière-plan, même lorsqu’un utilisateur se déconnecte du serveur. Cela rendra votre application persistante, vous rapprochant ainsi d’un déploiement de niveau production.

Tout d’abord, créez un nouveau fichier dans le répertoire + / lib / systemd / system nommé` + web.services` en utilisant + nano + ou votre éditeur de texte préféré:

sudo nano /lib/systemd/system/goweb.service

Pour définir les paramètres du service, ajoutez l’extrait de code suivant dans le fichier.

/lib/systemd/system/goweb.service

[Unit]
Description=goweb

[Service]
Type=simple
Restart=always
RestartSec=5s
ExecStart=/home//go/go-web/main

[Install]
WantedBy=multi-user.target

La variable + ExecStart = / home // go / go-web / main + indique que le point d’entrée de ce service se trouve dans l’exécutable + main + situé dans le répertoire + / home // go / go-web + répertoire, où ++ est le nom d’utilisateur du compte sudo non-root du serveur. + Restart = always + garantit que systemd essaiera toujours de redémarrer le programme s’il s’arrête. Sur la ligne suivante, + RestartSec = 5s + définit un délai d’attente de cinq secondes entre les tentatives de redémarrage. + WantedBy = multi-user.target + spécifie dans quel état votre serveur activera le service.

Enregistrez et quittez le fichier.

Maintenant que vous avez écrit le fichier d’unité de service, démarrez votre service Web Go en exécutant:

sudo service goweb start

Pour confirmer si le service est en cours d’exécution, utilisez la commande suivante:

sudo service goweb status

Vous recevrez le résultat suivant:

Output● goweb.service - goweb
  Loaded: loaded (/lib/systemd/system/goweb.service; disabled; vendor preset: enabled)
  Active: active (running) since Wed 2019-07-17 23:28:57 UTC; 6s ago
Main PID: 1891 (main)
   Tasks: 4 (limit: 1152)
  CGroup: /system.slice/goweb.service
          └─1891 /home//go/go-web/main

Pour en savoir plus sur l’utilisation du fichier d’unité systemd, consultez Comprendre les unités et les fichiers d’unités.

Maintenant que votre application est opérationnelle, vous pouvez configurer le proxy inverse Nginx.

Étape 3 - Configuration d’un proxy inverse avec Nginx

Dans cette étape, vous allez créer un bloc serveur Nginx et configurer un proxy inverse Nginx pour exposer votre application à Internet.

Commencez par changer votre répertoire de travail dans le répertoire Nginx + sites-available +:

cd /etc/nginx/sites-available

Créez un nouveau fichier avec le nom du domaine sur lequel vous souhaitez exposer votre application. Ce tutoriel utilisera ++:

sudo nano

Ajoutez les lignes suivantes dans le fichier pour définir les paramètres de ++:

/ etc / nginx / sites-available / votre_domaine

server {
   server_name  ;

   location / {
       proxy_pass http://localhost:9990;
   }
}

Ce bloc de serveur Nginx utilise http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_pass [+ proxy_pass +] pour servir l’application Web Go à l’adresse IP de votre serveur indiquée par + localhost + pour la créer. exécuté sur le port + 9990 +. + nom_serveur + indique le nom de domaine associé à votre adresse IP, dans ce cas ` et `.

Ensuite, créez un lien symbolique de cette configuration Nginx dans le dossier + sites-enabled + en exécutant la commande suivante:

sudo ln -s /etc/nginx/sites-available/ /etc/nginx/sites-enabled/

Un lien symbolique est un raccourci d’un fichier situé à un autre emplacement. Le raccourci nouvellement créé fera toujours référence au fichier d’origine afin de l’ajuster aux mises à jour lorsque des modifications y sont apportées. Nginx nécessite une copie de la configuration dans les deux répertoires.

Ensuite, rechargez vos configurations Nginx en exécutant la commande reload:

sudo nginx -s reload

Pour vous assurer que votre déploiement fonctionne, visitez + http: // + dans votre navigateur. Vous serez accueilli avec une chaîne de texte * Hello World *.

Vous avez maintenant configuré le proxy inverse Nginx pour exposer votre application sous votre nom de domaine et sécurisé votre application Web Go avec SSL / TLS. Dans l’étape suivante, vous testerez votre application via une connexion sécurisée.

Étape 4 - Test de l’application

Dans cette étape, vous testerez votre application via une connexion sécurisée pour vous assurer que tout fonctionne.

Ouvrez votre navigateur Web préféré, visitez + https: // +:

image: https: //assets.digitalocean.com/articles/66224/Hello_World.png [Bonjour la page d’affichage du monde]

Vous recevrez un simple message + Hello World +. Recevoir ce message en utilisant + https: // + dans l’URL indique que votre application est servie via une connexion sécurisée.

Ensuite, essayez de visiter la deuxième route + https: /// greet / +, en remplaçant ++ par le nom de votre choix pour que votre application salue:

image: https: //assets.digitalocean.com/articles/66224/Greet.png [Affichage de la page d’accueil]

L’application renverra un message d’accueil simple avec ++, basé sur le paramètre transmis à l’URL.

Une fois que vous avez reçu ces résultats, vous avez correctement déployé votre application Web Go.

Conclusion

Dans ce didacticiel, vous avez créé une application Web simple avec Go à l’aide de ses bibliothèques standard, configuré un proxy inverse à l’aide de Nginx et utilisé un certificat SSL sur votre domaine pour sécuriser votre application. Pour en savoir plus sur Go, consultez leur official documentation. Vous pouvez également consulter notre série How To Code in Go pour en savoir plus sur la programmation dans ce langage efficace.