Deployer Go sur DigitalOcean

Voici un tutoriel approfondi sur la façon de déployer une application Go sur DigitalOcean.

Pourquoi Déployer Go sur DigitalOcean ?

En tant que développeur, vous avez sûrement déjà travaillé avec des applications Go et appris à les exécuter localement. Cependant, dans un environnement de production réel, il est essentiel de déployer votre application sur un serveur distant pour la rendre accessible en ligne. DigitalOcean offre une solution idéale pour ce cas, offrant des serveurs performants et fiables à la demande.

Un cas d'usage concret serait l'hébergement d'une API web simple permettant aux utilisateurs de créer et de gérer leurs notes. Avec DigitalOcean, vous pouvez facilement déployer cette application et l'exposer sur Internet.

Prerequis

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

• Un compte DigitalOcean
• Une machine virtuelle (droplet) avec Ubuntu 20.04 LTS
• Go installé localement sur votre ordinateur (version 1.17 ou plus tard)
• Git installé pour cloner le dépôt de l'application

Concepts fondamentaux

Création d'un Droplet sur DigitalOcean

Pour commencer, connectez-vous à votre compte DigitalOcean et créez un nouveau droplet. Choisissez une taille appropriée (par exemple, la petite machine 1GB/1CPU) et sélectionnez Ubuntu 20.04 LTS comme image.

Installation de Go sur le Droplet

Une fois que votre droplet est créé, connectez-vous à celui-ci via SSH :

ssh root@votre_droplet_ip

Puis installez Go en suivant les instructions officielles :

wget https://go.dev/dl/go1.17.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.17.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

Création d'un Projet Go

Créez un nouveau répertoire pour votre projet et initialisez-le :

mkdir ~/my-go-app
cd ~/my-go-app
go mod init my-go-app

Créer un fichier main.go avec le contenu suivant :

package main

import (
	"fmt"
	"net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, World!")
}

func main() {
	http.HandleFunc("/", helloHandler)
	http.ListenAndServe(":8080", nil)
}

Exécution de l'Application

Vous pouvez maintenant exécuter votre application en local :

go run main.go

Ouvrez votre navigateur et allez à http://localhost:8080. Vous devriez voir "Hello, World!" affiché.

Mise en pratique : Projet fil rouge

Nous allons créer un mini-projet réaliste : une API de blog simple. Cette application permettra aux utilisateurs de créer et de récupérer des articles.

Étape 1 : Création du Projet

Créez un nouveau répertoire pour votre projet et initialisez-le :

mkdir ~/blog-api
cd ~/blog-api
go mod init blog-api

Créer les fichiers suivants :

• main.go
• models/blog.go
• routes/routes.go
• handlers/handlers.go

main.go

package main

import (
	"log"
	"net/http"

	"blog-api/routes"
)

func main() {
	r := routes.SetupRouter()
	log.Fatal(http.ListenAndServe(":8080", r))
}

models/blog.go

package models

type Article struct {
	ID      string `json:"id"`
	Title   string `json:"title"`
	Content string `json:"content"`
}

routes/routes.go

package routes

import (
	"blog-api/handlers"
	"github.com/gin-gonic/gin"
)

func SetupRouter() *gin.Engine {
	r := gin.Default()

	r.GET("/articles", handlers.GetArticles)
	r.POST("/articles", handlers.CreateArticle)

	return r
}

handlers/handlers.go

package handlers

import (
	"blog-api/models"
	"net/http"

	"github.com/gin-gonic/gin"
)

var articles = []models.Article{
	{ID: "1", Title: "Mon Premier Article", Content: "Contenu de l'article 1"},
}

func GetArticles(c *gin.Context) {
	c.JSON(http.StatusOK, articles)
}

func CreateArticle(c *gin.Context) {
	var newArticle models.Article
	if err := c.ShouldBindJSON(&newArticle); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	newArticle.ID = "2" // Simuler un ID unique
	articles = append(articles, newArticle)
	c.JSON(http.StatusCreated, newArticle)
}

Étape 2 : Exécution de l'Application

Exécutez votre application en local :

go run main.go

Ouvrez votre navigateur et allez à http://localhost:8080/articles. Vous devriez voir la liste des articles.

Erreurs frequentes et debugging

Erreur 1 : command not found: go

Code incorrect :

go run main.go

Code correct :

Assurez-vous que Go est installé correctement sur votre machine. Vous pouvez vérifier cela en exécutant :

go version

Erreur 2 : listen tcp :8080: bind: address already in use

Code incorrect :

http.ListenAndServe(":8080", nil)

Code correct :

Assurez-vous que aucun autre processus n'utilise déjà le port 8080. Vous pouvez vérifier cela en exécutant :

netstat -tuln | grep 8080

Erreur 3 : 404 Not Found

Code incorrect :

http.HandleFunc("/", helloHandler)

Code correct :

Assurez-vous que vous avez correctement défini les routes et que votre handler est associé à la bonne route. Par exemple :

r.GET("/articles", handlers.GetArticles)

Pour aller plus loin

1. Utilisation de Docker pour le déploiement

Docker permet de créer un environnement d'exécution cohérent entre développement et production.

• Documentation officielle

2. Gestion des dépendances avec Go Modules

Go Modules facilite la gestion des dépendances de votre projet.

• Documentation officielle

3. Utilisation d'un serveur web production réel

Nginx ou Apache sont des serveurs web performants pour l'production.

• Tutoriel sur Nginx avec Go

Défi pratique : Ajout d'une authentification

Ajoutez une fonctionnalité d'authentification à votre API de blog. Utilisez JWT (JSON Web Tokens) pour sécuriser les routes sensibles.

Ce tutoriel vous a permis de déployer une application Go simple sur DigitalOcean et de développer un projet réaliste : une API de blog. Vous avez également appris des erreurs courantes et des techniques de debugging utiles. N'oubliez pas d'explorer les pistes d'amélioration pour approfondir vos connaissances en développement Go et en déploiement sur DigitalOcean.