Bagaimanakah Go WebSocket mencapai pengimbangan beban?

Melaksanakan pengimbangan beban WebSocket dalam Go termasuk: mencipta pengendali WebSocket, menaik taraf permintaan HTTP dan memproses sambungan; membuat pengimbang beban undian, bertanggungjawab untuk memperuntukkan permintaan kepada pelayan, dan mengundi untuk memilih pelayan yang tersedia;

How Go WebSocket melaksanakan pengimbangan beban

Pengimbangan beban ialah cara mengedarkan permintaan kepada berbilang pelayan untuk meningkatkan ketersediaan dan prestasi. Pengimbangan beban amat penting dalam sambungan WebSocket kerana ia menghalang pelayan individu daripada terlebih muatan.

Berikut ialah panduan langkah demi langkah untuk melaksanakan pengimbangan beban WebSocket menggunakan Go:

1 Buat pengendali WebSocket

Pertama, anda perlu mencipta program yang mengendalikan permintaan WebSocket. Program ini boleh mengendalikan permintaan sambungan dan pertukaran mesej.

import "net/http"

// 升级 HTTP 请求并处理 WebSocket 连接
func WsUpgrade(res http.ResponseWriter, req *http.Request) {
    conn, err := websocket.Upgrade(res, req, nil, 1024, 1024)
    if err != nil {
        http.Error(res, "Could not establish websocket.", http.StatusBadRequest)
        return
    }
    defer conn.Close()

    // 处理 WebSocket 消息
    for {
        // 读取并处理传入的消息
        _, message, err := conn.ReadMessage()
        if err != nil {
            break
        }

        // 向客户端发送消息
        conn.WriteMessage(websocket.TextMessage, []byte("消息已收到："+string(message)))
    }
}

2. Cipta pengimbang beban

Untuk mencipta pengimbang beban, algoritma round robin digunakan untuk menentukan pelayan mana yang hendak dihalakan setiap permintaan.

import "sync"

// 轮训负载均衡器
type RoundRobinBalancer struct {
    lock    sync.Mutex
    servers []*websocket.Conn
    index   int
}

// 添加服务器
func (b *RoundRobinBalancer) AddServer(conn *websocket.Conn) {
    b.lock.Lock()
    defer b.lock.Unlock()
    b.servers = append(b.servers, conn)
}

// 选择服务器
func (b *RoundRobinBalancer) SelectServer() *websocket.Conn {
    b.lock.Lock()
    defer b.lock.Unlock()
    conn := b.servers[b.index]
    b.index = (b.index + 1) % len(b.servers)
    return conn
}

3. Sepadukan pengimbang beban

Sekarang, sepadukan pengimbang beban ke dalam pengendali WebSocket.

import (
    "net/http"
    "sync"

    "github.com/gorilla/websocket"
)

var (
    balancer = &RoundRobinBalancer{}
    once     sync.Once
)

// 升级 HTTP 请求并处理 WebSocket 连接
func HttpHandler(res http.ResponseWriter, req *http.Request) {
    conn, err := websocket.Upgrade(res, req, nil, 1024, 1024)
    if err != nil {
        http.Error(res, "Could not establish websocket.", http.StatusBadRequest)
        return
    }
    defer conn.Close()

    once.Do(func() {
        go balancer.Run() // 启动负载均衡器
    })

    balancer.AddServer(conn)

    // 启动协程发送数据
    go func() {
        for {
            // 读取并处理传入的消息
            _, message, err := conn.ReadMessage()
            if err != nil {
                break
            }

            conn.WriteMessage(websocket.TextMessage, []byte("消息已收到："+string(message)))
        }
    }()
}

Kes praktikal

• Pelayan penggunaan: Gunakan Docker atau Kubernetes untuk menggunakan berbilang contoh pelayan WebSocket.
• Mulakan pengimbang beban: Mulakan coroutine pengimbang beban dalam aplikasi.
• Mewujudkan sambungan WebSocket: Pelanggan boleh menyambung ke mana-mana pelayan yang tersedia dan pengimbang beban secara automatik akan menghalakan permintaan ke pelayan yang tersedia pada masa ini.

Dengan melaksanakan langkah-langkah ini, anda boleh mencipta aplikasi WebSocket berskala yang sangat tersedia dan berjalan dengan cekap walaupun dengan bilangan sambungan yang banyak.

Atas ialah kandungan terperinci Bagaimanakah Go WebSocket mencapai pengimbangan beban?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!