Guide de déploiement du serveur Golang WebSocket : atteindre la haute disponibilité

Avec le développement des applications Web, WebSocket, en tant que protocole réseau ouvert, est devenu l'un des outils importants pour la communication en temps réel. Dans ce cas, la capacité de déployer et de gérer un serveur WebSocket est essentielle. Cet article se concentre sur la façon de créer un serveur WebSocket à l'aide de Golang et fournit quelques exemples de code pour atteindre une haute disponibilité et une évolutivité.

1. Introduction au serveur Golang WebSocket

Dans Golang, nous pouvons utiliser des packages tiers pour créer des serveurs WebSocket. Ces packages fournissent des fonctionnalités utiles, telles que l'utilisation d'un serveur HTTP avec un serveur WebSocket et la fourniture d'opérations détaillées sur les sockets clients telles que les vérifications ping, pong et heartbeat.

Voici quelques-uns des packages les plus couramment utilisés :

1. Gorilla WebSocket
2. Go-WebSocket
3. Gobwas WebSocket

Dans cet article, nous utiliserons le package Gorilla WebSocket.

2. Implémenter le serveur WebSocket

Dans Golang, créer un serveur WebSocket est très simple. Nous pouvons créer le serveur WebSocket tout comme nous avons créé le serveur HTTP. Voici un exemple simple mais complet d'implémentation d'un serveur WebSocket :

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,

    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func reader(conn *websocket.Conn) {
    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("收到消息：%s
", message)
    }
}

func echoHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }

    go reader(conn)

    for {
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("收到消息：%s
", p)

        err = conn.WriteMessage(messageType, p)
        if err != nil {
            log.Println(err)
            return
        }
    }
}

func main() {
    http.HandleFunc("/echo", echoHandler)

    port := "8000"
    log.Printf("Starting server on port %v...
", port)

    err := http.ListenAndServe(fmt.Sprintf(":%v", port), nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

Dans le code ci-dessus, nous déclarons d'abord un websocket.Upgrader, qui met à niveau la connexion HTTP vers une connexion WebSocket. Ensuite, une fonction de lecture et une fonction echoHandler sont définies pour gérer respectivement les opérations de lecture et d'écriture de données.

Dans la fonction principale, nous définissons une route HTTP et lions le echoHandler au chemin "/echo". Enfin, nous avons démarré le serveur HTTP à l'aide de la fonction http.ListenAndServe et avons commencé à écouter toutes les requêtes sur le port 8000.

3. Haute disponibilité et évolutivité des serveurs WebSocket

Dans les applications pratiques, nous devons souvent déployer plusieurs serveurs WebSocket pour obtenir une haute disponibilité et une évolutivité. Dans ce cas, nous pouvons utiliser un équilibreur de charge pour gérer le serveur WebSocket. Un équilibreur de charge acheminera les requêtes des clients WebSocket vers plusieurs serveurs WebSocket pour obtenir une haute disponibilité et une évolutivité.

Ce qui suit est un exemple de configuration utilisant Nginx comme équilibreur de charge :

http {
    upstream websocket_servers {
        server 192.168.1.101:8000;
        server 192.168.1.102:8000;
        server 192.168.1.103:8000;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://websocket_servers;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "Upgrade";
            proxy_set_header Host $host;
        }
    }
}

Dans la configuration ci-dessus, nous avons défini trois serveurs WebSocket fonctionnant sur les adresses IP 192.168.1.101, 192.168.1.102 et 192.168.1.103 port 8000. Ensuite, nous avons défini un serveur Nginx en écoute sur le port 80. Nous transmettons toutes les demandes du client aux websocket_servers et définissons les en-têtes de proxy correspondants.

De cette façon, lorsque chaque serveur WebSocket est soumis à une charge élevée, Nginx peut automatiquement distribuer les requêtes aux autres serveurs et toujours empêcher la déconnexion de la connexion WebSocket.

4. Résumé

Cet article présente comment créer un serveur WebSocket à l'aide de Golang et fournit quelques exemples de code pour atteindre une haute disponibilité et une évolutivité. Nous avons utilisé le package Gorilla WebSocket pour implémenter le serveur WebSocket et expliqué comment utiliser Nginx comme équilibreur de charge pour déployer et gérer le serveur WebSocket.

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!