Comment gérez-vous les signaux dans une application Go?

La bonne façon de traiter les signaux dans les applications GO consiste à utiliser le package OS / Signal pour surveiller le signal et effectuer un arrêt élégant. 1. Utilisez Signal.Notify pour envoyer SIGINT, SIGTERM et d'autres signaux au canal; 2. Exécutez le service principal en goroutine et bloquez le signal d'attente; 3. Après avoir reçu le signal, effectuez un arrêt élégant avec le délai d'expiration via Context.withTimeout; 4. Nettoyer des ressources telles que la fermeture des connexions de la base de données et l'arrêt de la goroutine d'arrière-plan; 5. Utilisez le signal.Resine pour restaurer le comportement du signal par défaut lorsque cela est nécessaire pour vous assurer que le programme peut être terminé de manière fiable en Kubernetes et dans d'autres environnements.

La gestion des signaux dans une application Go est essentielle pour les fermetures gracieuses, le nettoyage et la réponse aux événements de niveau OS comme SIGTERM , SIGINT ou SIGHUP . Go fournit un moyen propre et simple de travailler avec des signaux via le package os/signal .

Voici comment vous gérez généralement les signaux en Go:

1. Utilisez signal.Notify .

L'approche principale consiste à configurer un écouteur de signal à l'aide de signal.Notify , qui envoie des signaux entrants à un canal. Cela se fait généralement dans un goroutine séparé afin qu'il ne bloque pas votre application principale.

 package principal

importer (
    "contexte"
    "FMT"
    "enregistrer"
    "net / http"
    "OS"
    "OS / Signal"
    "Syscall"
    "temps"
)

func main () {
    // Créer un serveur (exemple avec http)
    serveur: = & http.server {addr: ": 8080"}

    // Configuration du canal de signal
    STOP: = Make (Chan OS.Signal, 1)
    Signal.notify (stop, syscall.sigint, syscall.sigterm)

    // Démarrer le serveur dans un goroutine
    aller func () {
        Si err: = server.ListenandServe (); err! = nil && err! = http.errserverclosed {
            Log.fatalf ("Server échoué:% V", err)
        }
    } ()

    fmt.println ("Le serveur fonctionne sur: 8080 ...")

    // Bloquer jusqu'à ce qu'un signal soit reçu
    <-stop
    fmt.println ("\ nshutdown signal reçu.")

    // Arrêtez gracieusement le serveur
    ctx, annuler: = context.withtimeout (context.background (), 10 * time.second)
    Déférer annuler ()

    Si err: = server.shutdown (ctx); err! = Nil {
        Log.printf ("Erreur d&#39;arrêt du serveur:% V", ERR)
    }

    fmt.println ("Le serveur s&#39;est arrêté gracieusement.")
}

2. Signaux communs à gérer

• syscall.SIGINT - déclenché par Ctrl C (interruption).
• syscall.SIGTERM - Signal de terminaison gracieux (utilisé par des outils d'orchestration comme Kubernetes).
• syscall.SIGHUP - souvent utilisé pour recharger la configuration (commune dans les démons).

Vous pouvez inclure plusieurs signaux dans signal.Notify :

 Signal.notify (stop, syscall.sigint, syscall.sigter, syscall.sighup)

3. Fermements gracieux meilleures pratiques

• Évitez os.Exit() Sauf si nécessaire - il saute le nettoyage.
• Utilisez le contexte avec le délai d'expiration pour limiter la durée de l'arrêt.
• Ressources de fermeture: connexions de base de données, poignées de fichiers, écouteurs de réseau.
• Arrêtez les travailleurs de l'arrière-plan ou les Goroutines en utilisant l'annulation du contexte.

Exemple de nettoyage des tâches de fond:

 ctx, annuler: = context.withcancel (context.background ())

// simule une tâche d'arrière-plan
aller func () {
    Ticker: = Time.newTicker (2 * time.second)
    pour {
        sélectionner {
        cas <-ticker.c:
            fmt.println ("travail ...")
        cas <-ctx.done ():
            FMT.PRINTLN ("Le travailleur s&#39;est arrêté.")
            Retour
        }
    }
} ()

// plus tard, sur le signal:
<-stop
annuler () // arrêter le travailleur

4. N'oubliez pas de restaurer le comportement par défaut si nécessaire

Si vous construisez un démon de longue date ou si vous avez besoin d'arrêter temporairement d'écouter les signaux, vous pouvez utiliser signal.Reset() :

 déférer signal.reset (syscall.sigint, syscall.sigterm)

Cela restaure le comportement du signal par défaut après la sortie de votre programme.

La gestion des signaux garantit correctement que vos applications GO se comportent de manière prévisible dans les environnements de production - en particulier dans l'orchestration des conteneurs. Le motif est simple: écoutez sur un canal, bloquez jusqu'à ce qu'un signal arrive, puis nettoyez et sortez gracieusement.

Fondamentalement: configurez un canal, informez-le des signaux, attendez, puis fermez. Pas compliqué - mais facile à négliger.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!