Comment déployer une application Golang

Go (Golang ) est un langage de programmation développé par Google en 2009 pour résoudre des problèmes courants dans le développement de systèmes à grande échelle, comme la lenteur de la compilation et la nécessité d’une programmation concurrente.

Le langage a été conçu pour être simple, efficace et facile à utiliser, avec une syntaxe similaire à celle du C. En outre, Go est compilé, ce qui le rend plus rapide que les langages interprétés.

L’une des principales caractéristiques de Go est sa prise en charge de la concurrence, qui permet d’exécuter plusieurs tâches simultanément par le biais de threads légers appelés Goroutines.

Go est également connu pour sa forte prise en charge des réseaux et du développement web. La bibliothèque standard de Go contient des paquets pour HTTP, TCP/IP et d’autres protocoles de réseau, ce qui facilite la création d’applications en réseau.

Dans cet article, vous explorerez les avantages, les limites et les options de déploiement des applications Go. De plus, vous allez créer, dockeriser et déployer une application Go en utilisant le service de conteneurisation de Back4app gratuitement.

Poursuivez votre lecture pour découvrir comment déployer une application Go.

Avantages de Golang dans le développement Web

La popularité croissante de Go n’est pas le fruit du hasard. L’utilisation de Go pour vos applications présente de nombreux avantages.

Haute performance

Les performances élevées sont l’une des principales raisons pour lesquelles des entreprises comme Dropbox et Uber utilisent Go. Go est conçu pour des temps d’exécution rapides, ce qui fait de ce langage un choix idéal pour les applications nécessitant des performances élevées.

Go utilise un ramasse-miettes qui réduit la gestion de la mémoire, ce qui permet des temps d’exécution plus rapides. En outre, vous pouvez utiliser le support de concurrence intégré de Go pour augmenter les performances de votre application.

Évolutivité

Go est un excellent choix pour construire des applications évolutives. Grâce à la simultanéité, vous pouvez créer des programmes capables de gérer de nombreuses tâches, ce qui rend Go adapté aux applications qui gèrent des charges de trafic élevées et qui doivent être rapidement mises à l’échelle.

Go offre également une excellente prise en charge des systèmes distribués, ce qui en fait un choix idéal pour la création d’applications à grande échelle devant être exécutées sur plusieurs machines.

Go a fait ses preuves

De nombreuses entreprises populaires utilisent Go pour créer des applications à grande échelle, notamment celles utilisées par Google, Uber et Dropbox. Cela signifie que Go a été testé de manière approfondie et qu’il est fiable et stable pour la création d’applications complexes destinées à de vastes bases d’utilisateurs.

Go met fortement l’accent sur la compatibilité ascendante, et les applications écrites en Golang continueront à fonctionner même si le langage évolue.

Un soutien important de la part de la communauté

Depuis sa sortie, Go a été l’un des langages à la croissance la plus rapide en termes d’adoption, créant ainsi une communauté importante et active. Le fait que Go dispose d’une grande communauté active signifie que vous pouvez facilement trouver des ressources et des réponses à vos questions.

Go abrite de nombreuses bibliothèques et outils open-source que vous pouvez utiliser pour accélérer le temps de développement. Des outils de construction populaires comme Kubernetes, Docker et Hugo utilisent des paquets comme Cobra dans leurs outils CLI.

Limites de Golang

Bien que Golang soit un langage de programmation très performant et évolutif, Go a ses limites que vous devez prendre en compte avant de développer avec ce langage.

Complexité accrue pour certaines tâches

Go peut être facile à apprendre et à lire, mais certaines tâches sont plus faciles à réaliser dans d’autres langages qu’en Go. Construire une interface utilisateur interactive avec Go peut s’avérer difficile car Go a besoin d’une boîte à outils GUI intégrée, et les paquets tiers rendent votre projet plus complexe.

Le modèle de concurence de Go peut être difficile pour les débutants

Le modèle de concurrence de Go peut être difficile à comprendre et à utiliser pour les débutants. Go utilise des goroutines et des canaux pour la concurrence, qui sont des outils puissants mais qui peuvent être difficiles à comprendre. Vous devez apprendre à utiliser les canaux de manière efficace pour éviter les blocages ou les conditions de course.

Le modèle de concurrence de Go exige également que vous pensiez différemment à la structure et à la conception du code. Vous trouverez cela difficile si vous êtes habitué aux modèles de programmation séquentiels.

Ecosystème de bibliothèques moins mature que celui d’autres langues

Bien que la bibliothèque standard de Golang soit complète et dispose de la plupart des fonctionnalités dont vous aurez besoin pour créer des applications Go, elle est moins mature que les bibliothèques de langages tels que Java ou Python.

Golang est un langage de programmation relativement nouveau ; certaines bibliothèques populaires ne sont pas encore disponibles. Cela peut constituer une limitation pour certains projets, en particulier ceux qui requièrent des fonctionnalités plus spécialisées.

En outre, les bibliothèques tierces pour Golang sont moins répandues que celles disponibles pour d’autres langages, et vous devrez peut-être implémenter certaines fonctionnalités par vous-même, ce qui peut prendre du temps.

Options de déploiement de Golang

Après avoir créé des applications en Go, vous disposez de plusieurs options de déploiement, chacune présentant des avantages et des inconvénients.

Vous avez un large éventail d’options parmi les services IaaS comme AWS, les services PaaS comme Heroku, les services BaaS comme Back4app & Google Firebase, et les services CaaS comme Back4App Containers.

Infrastructure en tant que service (IaaS) comme AWS

Les fournisseurs d’infrastructure en tant que service (IaaS), tels qu’Amazon Web Services (AWS), proposent des fonctionnalités permettant de déployer et de gérer des machines virtuelles propres sur le nuage.

Avec AWS, vous pouvez utiliser des services comme Elastic Compute Cloud (EC2) pour déployer votre application Golang sur une machine virtuelle fonctionnant sous Linux ou Windows. Vous pouvez également utiliser des services comme Elastic Container Service (ECS) pour déployer votre application dans un conteneur.

L’un des avantages de l’utilisation d’un service IaaS tel qu’AWS est que vous avez un contrôle total sur l’infrastructure sous-jacente. Vous pouvez configurer la machine virtuelle pour qu’elle réponde à vos besoins spécifiques. Cependant, vous êtes responsable de la gestion et de la maintenance de la machine virtuelle, ce qui peut s’avérer technique et fastidieux.

Parmi les autres plateformes IaaS, citons

• Linode
• Microsoft Azure
• Rackspace
• Amazon Web Services (AWS)
• DigitalOcean
• Google Compute Engine (GCE)

Plateforme en tant que service (PaaS) comme Heroku

Les fournisseurs de plateforme en tant que service (PaaS) comme Heroku offrent une plateforme pour déployer des applications Golang sans perturber l’infrastructure sous-jacente.

Heroku fournit une interface de ligne de commande simple pour déployer votre application en quelques commandes seulement. Heroku prend également en charge la mise à l’échelle automatique et l’équilibrage de la charge, ce qui facilite la gestion d’un trafic élevé pour votre application.

L’avantage d’utiliser un service PaaS comme Heroku est que vous pouvez vous concentrer sur le développement de votre application sans vous soucier de l’infrastructure. Heroku s’occupe de la gestion et de la maintenance de l’infrastructure, ce qui vous permet d’économiser du temps et des ressources.

Toutefois, cela signifie également que vous avez moins de contrôle sur l’infrastructure et que vous devez travailler avec les limites de la plateforme.

Parmi les autres fournisseurs de PaaS, on peut citer

• Render
• AWS Elastic Beanstalk
• Microsoft Azure App Service
• DigitalOcean App Platform
• The Fly Platform

Backend as a Service (BaaS) comme Back4app

Les fournisseurs de Backend as a Service (BaaS) tels que Google Firebase et Back4app fournissent une solution backend complète pour votre application, y compris une base de données, l’authentification et l’hébergement. Firebase prend en charge plusieurs langages de programmation, dont Golang, et fournit une API simple que vous pouvez utiliser pour accéder à ses services.

L’un des avantages de l’utilisation d’un service BaaS tel que Firebase est que vous pouvez rapidement et facilement mettre en place un backend pour votre application sans avoir à gérer d’infrastructure. Firebase fournit une gamme de fonctionnalités et de services ; cependant, vous avez besoin de plus de contrôle sur l’infrastructure.

Parmi les autres plates-formes BaaS, citons

• AWS Amplify
• Cloudkit
• Backendless
• Back4App
• Pocketbase

La conteneurisation en tant que service comme Back4app Containers

La conteneurisation est populaire pour le déploiement d’applications. Grâce à la conteneurisation, vous pouvez regrouper votre application et ses dépendances dans un conteneur que vous pouvez rapidement déployer sur n’importe quelle plateforme qui prend en charge la technologie des conteneurs.

Back4App est un fournisseur de services de conteneurisation que vous pouvez utiliser pour déployer et gérer votre application Golang dans un conteneur.

Un des avantages d’utiliser la conteneurisation en tant que fournisseur de services comme Back4App est que vous pouvez déployer votre application sur n’importe quelle plateforme qui supporte les conteneurs sans vous soucier de l’infrastructure sous-jacente.

Le fournisseur CaaS s’occupe de la gestion et de la maintenance des conteneurs, ce qui vous permet de gagner du temps et d’économiser des ressources. Cependant, il se peut que vous deviez travailler dans les limites de la plateforme de conteneurisation sans avoir accès à l’infrastructure.

Parmi les autres plates-formes CaaS, citons

• AWS Container Service
• Azure Container Service
• Docker Enterprise
• Google Container Engine
• IBM Kubernetes Service
• Oracle Container Service

Processus de déploiement de Golang

Ici, vous apprendrez comment déployer votre application Golang sur la plateforme CaaS de Back4app.

Qu’est-ce que Back4app ?

Back4app est une offre cloud que vous pouvez utiliser pour créer et déployer des services backend pour vos applications mobiles et web.

Vous pouvez utiliser la fonctionnalité CaaS de Back4app pour déployer et exécuter des conteneurs personnalisés sur les serveurs backend de Back4app. Vous pouvez ajouter une logique personnalisée à votre application en utilisant vos images de conteneurs sans avoir à gérer votre infrastructure de serveur.

Dans cette section, vous apprendrez à construire une simple API RESTful CRUD en Go, à conteneuriser des programmes Go et à déployer le conteneur sur Back4app.

Configuration de l’environnement de développement

Après avoir installé Go sur votre machine à partir de la page de téléchargement, vous pouvez créer un nouveau répertoire et initialiser un nouveau projet Go pour votre application Go.

Exécutez la commande ci-dessous pour créer un nouveau répertoire pour votre projet.

mkdir deployAPI && cd deployAPI

Exécutez la commande mod init pour initialiser un nouveau projet dans votre répertoire de travail actuel avec l’outil Go.

Comme cela :

go mod init

Vous construirez l’API RESTful avec le paquet Gorilla Mux.

Exécutez la commande ci-dessous pour installer le paquet Gorilla Mux en tant que dépendance de votre projet.

go get -u github.com/gorilla/mux

L’étape suivante est la construction de l’API RESTful. La première étape dans la construction d’une API RESTful avec Gorilla Mux est d’importer les paquets nécessaires dans votre fichier Go.

Voici la liste des importations nécessaires au projet.

import (
	"encoding/json"
	"log"
	"net/http"
	"strconv"

	"github.com/gorilla/mux"
)

Après avoir dressé la liste de vos importations, vous devrez mettre en place une base de données pour votre application. Par souci de simplicité, nous utiliserons une carte pour stocker et récupérer les données.

Vous pouvez ajouter la carte à votre application comme suit :

var users = map[int]string{}

Comme la carte est vide, vous devez saisir des données à l’aide d’une requête POST.

La fonction POST Request Handler (gestionnaire de requêtes POST)

Votre requête POST doit recevoir les données du client, les analyser et les enregistrer dans le magasin de données de la carte.

Ajoutez le bloc de code à votre application pour mettre en œuvre le gestionnaire de requête POST :

func createUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	var data map[string]string

	err = json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	users[id] = data["name"]

	w.WriteHeader(http.StatusCreated)
}

La fonction createUserHandler handler reçoit les données du client (JSON), les analyse et les enregistre dans la carte. Lorsque le gestionnaire ajoute avec succès les données à la carte, il écrit le code de réussite StatusCreated au client.

La demande GET

Vous lirez les données du magasin de données à l’aide d’une requête GET. Votre fonction de traitement des requêtes GET récupérera un identifiant auprès du client, effectuera une recherche et renverra les données au client.

Ajoutez le bloc de code à votre application pour mettre en œuvre le gestionnaire de requêtes GET :

func readUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	name, ok := users[id]
	if !ok {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	data := map[string]string{"name": name}

	jsonData, err := json.Marshal(data)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	w.Write(jsonData)
}

La fonction readUserHandler récupère l’identifiant à l’aide de la fonction Vars du paquet mux et recherche les données dans la carte avant de les renvoyer au client sous forme de JSON, accompagnées d’un code de réussite StatusOk.

La fonction de gestion des requêtes PUT

Vous mettrez à jour les données de votre magasin de données à l’aide d’une requête PUT. Votre gestionnaire de requête PUT acceptera l’ID et un champ JSON pour le processus de mise à jour.

func updateUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	var data map[string]string

	err = json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	users[id] = data["name"]

	w.WriteHeader(http.StatusOK)
}

La fonction updateUserHandler prend l’ID avec la variable vars, décode le JSON du corps de la requête et met à jour le champ ou l’ID avec les données JSON du corps de la requête.

La fonction DELETE Request Handler (gestionnaire de requêtes DELETE)

Votre fonction de traitement des requêtes DELETE récupère l’identifiant du champ dans la requête et supprime le champ du magasin de données.

Ajoutez le bloc de code à votre application pour mettre en œuvre le gestionnaire de requête DELETE :

func deleteUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	delete(users, id)

	w.WriteHeader(http.StatusOK)
}

La fonction deleteUserHandler supprime le champ à l’aide de la fonction delete qui prend en compte le nom de la carte et l’ID et renvoie le code StatusOk au client.

Montage des fonctions du gestionnaire sur les routes

Après avoir défini les points de terminaison de votre application, vous devez affecter les fonctions de traitement aux routes. Les routes constituent l’interface publique de votre API.

func main() {
	r := mux.NewRouter()

	r.HandleFunc("/users/{id}", createUserHandler).Methods(http.MethodPost)
	r.HandleFunc("/users/{id}", readUserHandler).Methods(http.MethodGet)
	r.HandleFunc("/users/{id}", updateUserHandler).Methods(http.MethodPut)
	r.HandleFunc("/users/{id}", deleteUserHandler).Methods(http.MethodDelete)

	log.Fatal(http.ListenAndServe(":8080", r))
}

Dans la fonction principale, r est une instance d’un nouveau routeur mux, et la méthode HandleFunc prend en charge une route et une fonction handler. La fonction Methods spécifie les méthodes HTTP sur les routes.

Conteneuriser les applications Go avec Docker

Docker est l’une des technologies de conteneurisation les plus populaires. Docker a été conçu avec Go, et vous pouvez conteneuriser vos applications Go pour les rendre portables avec Docker.

Vous devrez créer un nouveau fichier docker dans lequel vous spécifierez les instructions de construction.

Exécutez la commande ci-dessous pour créer un fichier Docker dans le répertoire de travail de votre projet.

touch Dockerfile

Ouvrez le fichier Docker et collez ces instructions de construction pour conteneuriser votre application Go avec Docker.

# Use an official Golang runtime as a parent image
FROM golang:latest

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Download and install any required dependencies
RUN go mod download

# Build the Go app
RUN go build -o main .

# Expose port 8080 for incoming traffic
EXPOSE 8080

# Define the command to run the app when the container starts
CMD ["/app/main"]

Les instructions de construction dans le fichier docker spécifient la version de Go pour le projet, le répertoire de travail, les fichiers pour l’application et les instructions de construction pour le fichier docker.

Voici la décomposition du fichier Docker :

• Le fichier commence par FROM golang : latest qui spécifie que vous voulez utiliser la dernière version de l’image officielle de Golang comme image de base pour votre conteneur Docker.
• La ligne WORKDIR /app définit le répertoire de travail de votre conteneur comme étant le répertoire /app.
• La commande COPY . /app copie le contenu de votre répertoire actuel dans le répertoire /app du conteneur.
• Le téléchargement RUN go mod télécharge les dépendances nécessaires à votre application.
• La commande RUN go build -o main . compile votre application Go et crée un fichier exécutable nommé main dans le répertoire /app.
• La ligne EXPOSE 8080 indique à Docker d’exposer le port 8080, le port sur lequel votre application Go écoute les requêtes entrantes.
• La ligne CMD ["/app/main"] spécifie la commande à exécuter au démarrage du conteneur (dans ce cas, l’exécutable principal ).

Lors de l’exécution du fichier docker, Docker construit l’image de l’application et expose l’application sur le port 8080.

La commande démarre le conteneur et fait correspondre le port 8080 de la machine hôte au port 8080 du conteneur, et vous devriez pouvoir accéder à l’API sur [http://localhost:8080](http://localhost:8080).

Déploiement du conteneur sur Back4app

Vous devez créer un compte sur Back4app (si vous n’en avez pas) pour déployer des conteneurs.

Voici les étapes pour créer un compte sur Back4app.

1. Rendez-vous sur le site web de Back4app.
2. Cliquez sur le bouton S’inscrire dans le coin supérieur droit de la page d’accueil pour créer un nouveau compte.
3. Enfin, remplissez le formulaire d’inscription et envoyez-le.

Après avoir créé votre compte Back4app, connectez-vous à votre compte et cliquez sur le bouton NEW APP dans le coin supérieur droit de l’interface utilisateur.

Le bouton NEW APP vous amène à une page où vous pouvez choisir comment déployer votre application. Puisque vous déployez un conteneur, sélectionnez l’option Conteneurs en tant que service.

Ensuite, connectez votre compte GitHub à votre compte Back4app. Vous pouvez choisir de donner à Back4app l’accès au code source de tous les dépôts de votre compte ou à un répertoire de projet spécifique.

Choisissez l’application que vous souhaitez déployer, dans ce cas, l’application que vous avez créée dans ce tutoriel, puis cliquez sur Sélectionner.

En cliquant sur le bouton de sélection, vous accédez à une page où vous devez remplir les informations relatives à votre application, du nom à la branche, en passant par le répertoire racine et les variables d’environnement.

Veillez à remplir toutes les variables environnementales nécessaires à votre application. Une fois que vous avez rempli les informations requises, cliquez sur Créer une application.

En cliquant sur ce bouton, vous lancez le processus de déploiement de votre application Go, comme le montre l’image ci-dessous.

Conclusion

Vous avez appris à déployer une application Go conteneurisée sur Back4app. En suivant les étapes de ce tutoriel, vous devriez avoir une API Go fonctionnant sur Back4app.

Déployer vos applications sur Back4app est un excellent moyen de simplifier la gestion de l’infrastructure backend. Back4App fournit des outils puissants pour la gestion de vos données, la mise à l’échelle de votre application et le contrôle de ses performances. C’est un excellent choix pour les développeurs qui cherchent à créer de grandes applications plutôt qu’à gérer des serveurs.

FAQ