Deployer Go sur Fly.io

Pourquoi Deployer Go sur Fly.io ?

Deploiement : le processus d'installation et de mise en production d'une application. Il est crucial pour les développeurs pour rendre leurs logiciels accessibles aux utilisateurs finaux. Pour un backend Go, Fly.io offre une solution simple et rapide, permettant de déployer des applications Go sans nécessiter des serveurs physiques.

Un cas d'usage concret : Imaginez que vous développez un service web qui gère les réservations d'hôtels. Vous avez besoin d'une infrastructure robuste pour traiter les requêtes en temps réel, gérer les échecs de réseau et redémarrer automatiquement votre application en cas de panne.

Prerequis

• Connaissances en Go : Variables, structures de contrôle, fonctions, etc.
• Familiarité avec le terminal
• Un compte Fly.io (gratuit pour le débogage)

Outils à installer :

• Go 1.16 ou plus tard (https://golang.org/dl/)
• Flyctl (outil de ligne de commande) : curl -L https://fly.io/install | sh
• Git (pour la gestion des versions du code, optionnel mais recommandé)

Concepts fondamentaux

1. Structure du projet Go

// main.go
package main

import (
    "fmt"
    "net/http"
)

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

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

2. Manifeste Fly.io

Fly.io utilise un fichier fly.toml pour configurer le déploiement.

## fly.toml
app = "mon-app"
kill_signal = "SIGINT"
kill_timeout = 5
processes = [
    {type="web", command="go run main.go"}
]

3. Déploiement

Pour déployer votre application sur Fly.io :

## Initialiser le déploiement
fly launch --name mon-app --dockerfile Dockerfile

## Construire et déployer l'image
fly deploy

Mise en pratique : Projet fil rouge - Gestionnaire de tâches (Todo List)

Étape 1 : Création du projet

mkdir todo-list-go
cd todo-list-go
go mod init todo-list-go
touch main.go fly.toml

Étape 2 : Code source

main.go

// main.go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type Task struct {
    ID        int       `json:"id"`
    Title     string    `json:"title"`
    Completed bool      `json:"completed"`
}

var tasks = []Task{
    {ID: 1, Title: "Acheter du lait", Completed: false},
    {ID: 2, Title: "Faire les courses", Completed: true},
}

func getTasks(w http.ResponseWriter, r *http.Request) {
    json.NewEncoder(w).Encode(tasks)
}

func addTask(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
    }
    tasks = append(tasks, newTask)
    w.WriteHeader(http.StatusCreated)
}

func main() {
    http.HandleFunc("/tasks", func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case "GET":
            getTasks(w, r)
        case "POST":
            addTask(w, r)
        default:
            http.Error(w, "Méthode non autorisée", http.StatusMethodNotAllowed)
        }
    })
    http.ListenAndServe(":8080", nil)
}

fly.toml

## fly.toml
app = "todo-list-go"
kill_signal = "SIGINT"
kill_timeout = 5
processes = [
    {type="web", command="go run main.go"}
]

Étape 3 : Déploiement

## Initialiser le déploiement
fly launch --name todo-list-go --dockerfile Dockerfile

## Construire et déployer l'image
fly deploy

Erreurs fréquentes et debugging

Erreur 1 : Port non disponible

// ❌ Mauvais
http.ListenAndServe(":8080", nil)

Correction :

// ✅ Correct
port := os.Getenv("PORT")
if port == "" {
    port = "8080"
}
http.ListenAndServe(":"+port, nil)

Erreur 2 : Erreur de décodage JSON

// ❌ Mauvais
err := json.NewDecoder(r.Body).Decode(&newTask)

Correction :

// ✅ Correct
decoder := json.NewDecoder(r.Body)
if err := decoder.Decode(&newTask); err != nil {
    http.Error(w, err.Error(), http.StatusBadRequest)
    return
}

Erreur 3 : Erreur de gestion des erreurs

// ❌ Mauvais
err := json.NewEncoder(w).Encode(tasks)

Correction :

// ✅ Correct
if err := json.NewEncoder(w).Encode(tasks); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
}

Pour aller plus loin

1. Mise en production complète : Déployer une application Go sur Fly.io avec un environnement de production complet.
2. Ajout d'une base de données : Utiliser une base de données comme PostgreSQL pour stocker les tâches.
3. Tests unitaires et d'intégration : Ajouter des tests pour votre application.

Défi pratique : Créez une petite API RESTful en Go avec Fly.io qui permet de gérer les utilisateurs, y compris la création, la lecture, la mise à jour et la suppression d'utilisateurs.