Go Academy · Leçon

Gestion des connexions

Gérer les déconnexions

Gestion des connexions est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Les connexions ne durent pas éternellement

Les clients ferment des onglets, perdent le Wi-Fi ou se bloquent. Les serveurs WebSocket robustes doivent détecter les déconnexions, libérer les ressources et arrêter les gouroutines. Sinon, vous provoquez des fuites de mémoire et de sockets.

La négociation de fermeture

Un arrêt propre envoie une trame de fermeture dans les deux directions. gorilla le signale sous la forme d'une erreur renvoyée par ReadMessage, avec un code de fermeture que vous pouvez examiner.

if websocket.IsCloseError(err, websocket.CloseNormalClosure) {
    // graceful close
}

Maintien en vie par ping/pong

Pour détecter une connexion semi-ouverte, lorsque le pair a disparu sans fermer la connexion, le serveur envoie périodiquement des trames de contrôle ping et attend des réponses pong.

conn.SetPongHandler(func(string) error {
    conn.SetReadDeadline(time.Now().Add(60 * time.Second))
    return nil
})

Délais de lecture

Définissez un délai de lecture afin qu'un pair défaillant finisse par provoquer une erreur au lieu de bloquer indéfiniment. Actualisez ce délai chaque fois qu'un pong arrive.

conn.SetReadDeadline(time.Now().Add(60 * time.Second))

Le déclencheur périodique des ping

Un déclencheur périodique dans la gouroutine d'écriture envoie des ping à intervalles réguliers. Si une écriture échoue, la connexion est morte et vous quittez la gouroutine.

ticker := time.NewTicker(54 * time.Second)
defer ticker.Stop()
for range ticker.C {
    if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
        return
    }
}

Nettoyage à la sortie

Lorsqu'une boucle de lecture ou d'écriture se termine, désinscrivez le client et fermez la connexion. defer garantit cette opération même en cas de panique.

defer func() {
    hub.unregister <- client
    conn.Close()
}()

Deux gouroutines par connexion

Le modèle standard exécute un readPump et un writePump par connexion. Lorsque l'une détecte une erreur, elle déclenche le nettoyage qui arrête l'autre, souvent en fermant le canal d'envoi.

Délais d'écriture également

Définissez des délais d'écriture afin qu'une écriture bloquée ne fasse pas attendre une gouroutine indéfiniment. Une écriture ayant dépassé le délai renvoie une erreur et vous démantelez la connexion.

conn.SetWriteDeadline(time.Now().Add(10 * time.Second))

Arrêt progressif du serveur

Lors de l'arrêt du serveur, envoyez une trame de fermeture à chaque client et attendez brièvement. Combinez cela avec http.Server.Shutdown et un délai pour le contexte.

conn.WriteMessage(websocket.CloseMessage,
    websocket.FormatCloseMessage(websocket.CloseGoingAway, "bye"))

Reconnexion côté client

Les déconnexions sont normales. Les clients doivent mettre en œuvre une logique de reconnexion avec temporisation exponentielle. Côté serveur, il suffit de gérer proprement chaque connexion et chaque déconnexion.

Exécutable : analogie avec la détection des délais

Le maintien en vie de WebSocket nécessite la bibliothèque ; ce programme utilisant la bibliothèque standard représente une vérification de l'activité fondée sur un délai, avec un minuteur et un canal.

package main

import (
    "fmt"
    "time"
)

func main() {
    pong := make(chan struct{})
    go func() {
        time.Sleep(20 * time.Millisecond) // simulate a slow/absent peer
        _ = pong                          // no pong sent -> dead connection
    }()
    select {
    case <-pong:
        fmt.Println("alive")
    case <-time.After(10 * time.Millisecond):
        fmt.Println("no pong: closing dead connection")
    }
}

Vérification rapide

Vérifiez votre compréhension de la gestion des connexions.

Récapitulatif

Vous avez appris à gérer les connexions :

Gérez la négociation de fermeture et examinez les codes de fermeture
Utilisez ping/pong ainsi que des délais de lecture et d'écriture pour détecter les pairs défaillants
Exécutez les boucles de lecture et d'écriture ; nettoyez les ressources avec defer
Arrêtez le serveur progressivement avec des trames de fermeture ; les clients se reconnectent avec une temporisation exponentielle

Questions Fréquemment Posées

La leçon « Gestion des connexions » est-elle gratuite ?

Oui — le texte complet de « Gestion des connexions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gestion des connexions » ?

Gérer les déconnexions Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Gestion des connexions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy