panduan penggunaan pelayan WebSocket golang: mencapai ketersediaan tinggi

Dengan pembangunan aplikasi Web, WebSocket, sebagai protokol rangkaian terbuka, telah menjadi salah satu alat penting untuk komunikasi masa nyata. Dalam kes ini, keupayaan untuk menggunakan dan mengurus pelayan WebSocket adalah kritikal. Artikel ini memberi tumpuan kepada cara membina pelayan WebSocket menggunakan Golang dan menyediakan beberapa contoh kod untuk mencapai ketersediaan dan kebolehskalaan yang tinggi.

1. Pengenalan kepada pelayan WebSocket Golang

Di Golang, kami boleh menggunakan pakej pihak ketiga untuk membuat pelayan WebSocket. Pakej ini menyediakan beberapa fungsi yang berguna, seperti menggunakan pelayan HTTP dengan pelayan WebSocket dan menyediakan operasi soket pelanggan terperinci seperti ping, pong dan pemeriksaan degupan jantung.

Berikut ialah beberapa pakej yang lebih biasa digunakan:

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

Dalam artikel ini, kami akan menggunakan pakej Gorilla WebSocket.

2. Laksanakan pelayan WebSocket

Di Golang, mencipta pelayan WebSocket adalah sangat mudah. Kita boleh mencipta pelayan WebSocket sama seperti kita mencipta pelayan HTTP. Berikut ialah contoh ringkas tetapi lengkap pelaksanaan pelayan 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)
    }
}

Dalam kod di atas, kami mula-mula mengisytiharkan websocket.Upgrader, yang meningkatkan sambungan HTTP kepada sambungan WebSocket. Seterusnya, fungsi pembaca dan fungsi echoHandler ditakrifkan untuk mengendalikan operasi membaca dan menulis data masing-masing.

Dalam fungsi utama, kami mentakrifkan laluan HTTP dan mengikat echoHandler ke laluan "/echo". Akhirnya, kami memulakan pelayan HTTP menggunakan fungsi http.ListenAndServe dan mula mendengar semua permintaan pada port 8000.

3. Ketersediaan tinggi dan skalabiliti pelayan WebSocket

Dalam aplikasi praktikal, kami selalunya perlu menggunakan berbilang pelayan WebSocket untuk mencapai ketersediaan dan kebolehskalaan yang tinggi. Dalam kes ini, kita boleh menggunakan pengimbang beban untuk mengurus pelayan WebSocket. Pengimbang beban akan menghalakan permintaan klien WebSocket ke berbilang pelayan WebSocket untuk mencapai ketersediaan dan kebolehskalaan yang tinggi.

Berikut ialah contoh konfigurasi menggunakan Nginx sebagai pengimbang beban:

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;
        }
    }
}

Dalam konfigurasi di atas, kami telah menentukan tiga pelayan WebSocket yang berjalan pada alamat IP 192.168.1.101, 192.168.1.102 dan 192.1068.8.1. Kemudian, kami menentukan pelayan Nginx yang mendengar pada port 80. Kami memajukan semua permintaan daripada klien ke websocket_servers dan menetapkan pengepala proksi yang sepadan.

Dengan cara ini, apabila setiap pelayan WebSocket berada di bawah beban yang tinggi, Nginx boleh secara automatik mengedarkan permintaan kepada pelayan lain dan sentiasa memastikan sambungan WebSocket daripada terputus.

4. Ringkasan

Artikel ini memperkenalkan cara membina pelayan WebSocket menggunakan Golang dan menyediakan beberapa contoh kod untuk mencapai ketersediaan dan kebolehskalaan yang tinggi. Kami menggunakan pakej Gorilla WebSocket untuk melaksanakan pelayan WebSocket dan membincangkan cara menggunakan Nginx sebagai pengimbang beban untuk menggunakan dan mengurus pelayan WebSocket.

Atas ialah kandungan terperinci panduan penggunaan pelayan WebSocket golang: mencapai ketersediaan tinggi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!