Déployer Go sur Vercel
Pourquoi Deployer Go sur Vercel ?
Deployer une application Go sur Vercel offre plusieurs avantages. En tant que langage de programmation performant et concurrentiel, Go est idéal pour créer des applications web modernes et réactives. Vercel, quant à lui, est une plateforme d'hébergement serverless qui permet de déployer rapidement et efficacement les applications modernes, tout en offrant une grande échelle.
Un cas concret de déploiement Go sur Vercel serait la création d'une application web simple pour un blog. Avec Vercel, vous pouvez créer une API RESTful pour gérer les articles du blog, puis déployer ce backend rapidement et facilement sans préoccupation de l'hébergement.
Prerequis
- Connaissance de base de Go
- Connaissance des bases de l'API HTTP en Go
- Compteur Vercel (gratuit pour les petites applications)
Outils à installer :
- Go (version 1.18 ou plus récente)
- Node.js (pour le CLI Vercel, version 14 ou plus récente)
- Git (optionnel, mais recommandé)
Concepts fondamentaux
1. Serveur HTTP avec Go
Go offre une bibliothèque standard pour créer des serveurs HTTP. Voici un exemple simple :
// main.go
package main
import (
"fmt"
"net/http"
)
func helloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, Vercel!")
}
func main() {
http.HandleFunc("/", helloHandler)
http.ListenAndServe(":3000", nil)
}
Ce code crée un simple serveur HTTP qui répond avec "Hello, Vercel!" à chaque requête sur la racine.
2. Déploiement serverless avec Vercel
Vercel utilise le concept de Functions (fonctions) pour permettre des déploiements serverless. Voici comment configurer une fonction simple :
// functions/hello.js
export default function handler(req, res) {
res.status(200).json({ message: 'Hello from Vercel!' });
}
Ce code définit une fonction qui retourne un JSON avec un message.
3. Configuration de Vercel
Pour déployer sur Vercel, vous devez créer un fichier vercel.json à la racine de votre projet :
{
"version": 2,
"functions": {
"hello.js": {
"runtime": "nodejs14.x"
}
}
}
Ce fichier configure Vercel pour utiliser le runtime Node.js v14.x.
Mise en pratique : projet fil rouge
Nous allons créer un simple gestionnaire de tâches avec Go. Voici les étapes :
Étape 1 : Créer un nouveau projet Go
mkdir task-manager
cd task-manager
go mod init task-manager
Étape 2 : Créer le serveur HTTP
Créer un fichier main.go :
// main.go
package main
import (
"encoding/json"
"fmt"
"net/http"
)
type Task struct {
ID int `json:"id"`
Name string `json:"name"`
Done bool `json:"done"`
}
var tasks = []Task{
{ID: 1, Name: "Buy groceries", Done: false},
{ID: 2, Name: "Clean the house", Done: true},
}
func getTasksHandler(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(tasks)
}
func createTaskHandler(w http.ResponseWriter, r *http.Request) {
var newTask Task
err := json.NewDecoder(r.Body).Decode(&newTask)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
newTask.ID = len(tasks) + 1
tasks = append(tasks, newTask)
json.NewEncoder(w).Encode(newTask)
}
func updateTaskHandler(w http.ResponseWriter, r *http.Request) {
var updatedTask Task
err := json.NewDecoder(r.Body).Decode(&updatedTask)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
for i, task := range tasks {
if task.ID == updatedTask.ID {
tasks[i] = updatedTask
json.NewEncoder(w).Encode(updatedTask)
return
}
}
http.Error(w, "Task not found", http.StatusNotFound)
}
func deleteTaskHandler(w http.ResponseWriter, r *http.Request) {
var taskToDelete Task
err := json.NewDecoder(r.Body).Decode(&taskToDelete)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
for i, task := range tasks {
if task.ID == taskToDelete.ID {
tasks = append(tasks[:i], tasks[i+1:]...)
json.NewEncoder(w).Encode(taskToDelete)
return
}
}
http.Error(w, "Task not found", http.StatusNotFound)
}
func main() {
http.HandleFunc("/tasks", func(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
getTasksHandler(w, r)
case http.MethodPost:
createTaskHandler(w, r)
default:
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
})
http.HandleFunc("/tasks/", func(w http.ResponseWriter, r *http.Request) {
id := getIDFromPath(r.URL.Path)
switch r.Method {
case http.MethodGet:
task, err := getTaskByID(id)
if err != nil {
http.Error(w, err.Error(), http.StatusNotFound)
return
}
json.NewEncoder(w).Encode(task)
case http.MethodPut:
updateTaskHandler(w, r)
case http.MethodDelete:
deleteTaskHandler(w, r)
default:
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
})
http.ListenAndServe(":3000", nil)
}
func getIDFromPath(path string) int {
idStr := path[len("/tasks/"):len(path)]
id, err := strconv.Atoi(idStr)
if err != nil {
return 0
}
return id
}
func getTaskByID(id int) (*Task, error) {
for _, task := range tasks {
if task.ID == id {
return &task, nil
}
}
return nil, fmt.Errorf("task not found")
}
Étape 3 : Ajouter les fichiers Vercel
Créer un fichier vercel.json :
{
"version": 2,
"functions": {
"main.go": {
"runtime": "go118"
}
},
"routes": [
{ "src": "/(.*)", "dest": ":splat", "continue": true },
{ "src": "(.*)", "headers": { "x-foo": "bar" } }
]
}
Créer un fichier package.json pour Vercel :
{
"name": "task-manager",
"version": "1.0.0",
"type": "go"
}
Étape 4 : Déployer sur Vercel
Connectez-vous à votre compte Vercel et importez le dépôt Git de votre projet ou téléchargez-le localement et utilisez la commande :
vercel
Erreurs frequentes et debugging
- Erreur :
Could not find a main Go file
Le message d'erreur indique que Vercel ne trouve pas le fichier main.go. Assurez-vous que votre projet contient un fichier main.go à la racine.
## ❌ Mauvais
// Aucun fichier main.go
## ✅ Correct
package main
import "fmt"
func main() {
fmt.Println("Hello, Vercel!")
}
- Erreur :
Could not find a valid Go module
Le message d'erreur indique que Vercel ne trouve pas le fichier go.mod. Assurez-vous que vous avez initialisé un module Go en utilisant la commande :
go mod init task-manager
- Erreur :
Module cannot be found in the GOPATH
Le message d'erreur indique que Vercel ne trouve pas le module dans le chemin du GOPATH. Assurez-vous que votre projet est bien structuré et que vous utilisez les bons chemins.
## ❌ Mauvais
// Utilisation de chemins incorrects
## ✅ Correct
package main
import (
"fmt"
"net/http"
)
Pour aller plus loin
- Gestion des erreurs HTTP personnalisées
Vous pouvez créer des fonctions pour gérer les erreurs HTTP personnalisées.
- Utilisation de middleware
Vous pouvez utiliser le middleware pour ajouter des fonctionnalités comme l'authentification et la validation des données.
- Optimisation des performances
Vercel offre plusieurs options pour optimiser les performances de vos applications, telles que la mise en cache et la compression du contenu.
Défi pratique
Tentez de créer une application Go qui utilise un système de base de données pour stocker les tâches plutôt que de les garder en mémoire. Vous pouvez utiliser SQLite ou MySQL pour cela.
Ce tutoriel vous a permis de comprendre comment déployer une application Go sur Vercel, des concepts fondamentaux à la mise en pratique d'un projet complet.