Quelle est la séquence d'actions nécessaire pour arrêter correctement l'application sans perte de données ou défaillance?

Pour arrêter correctement une application Go sans perte de données ni erreurs, on suit généralement les étapes suivantes :

1. Gestion des signaux du système d'exploitation — capturer les signaux de terminaison (SIGINT, SIGTERM) à l'aide d'un canal et signal.Notify.

2. Démarrage d'une fermeture en douceur (graceful shutdown) — lancer une procédure de fermeture progressive, qui cesse d'accepter de nouvelles requêtes et laisse les requêtes en cours se terminer.

3. Annulation du contexte — utiliser context.Context avec annulation pour transmettre le signal d'arrêt à toutes les goroutines.

4. Fermeture des ressources — fermer les connexions ouvertes à la base de données, fichiers, connexions réseau.

5. Attente de la fin des goroutines — utiliser sync.WaitGroup ou d'autres mécanismes pour attendre que toutes les opérations se terminent.

Exemple de gestion de signal et de shutdown en douceur :

import (
    "context"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup

    // Démarrage de l'application
    wg.Add(1)
    go func() {
        defer wg.Done()
        runApp(ctx) // fonction avec la logique principale
    }()

    // Gestion des signaux
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    <-sigs // attente du signal
    cancel() // annulation du contexte, signalant aux goroutines

    // Attente de la fin
    done := make(chan struct{})
    go func() {
        wg.Wait()
        close(done)
    }()

    select {
    case <-done:
        // Tout a terminé
    case <-time.After(10 * time.Second):
        // Timeout d'attente
    }
}

Cette approche permet d'éviter la perte de données et une fermeture incorrecte.