EP.59 การทำให้ WebSocket Server รองรับการสเกล (Scalability) ด้วย Redis

ฟีเจอร์การรองรับการสเกล (scalability) ด้วย Redis จะช่วยให้ WebSocket Server สามารถจัดการกับการเชื่อมต่อที่มีจำนวนมากได้อย่างมีประสิทธิภาพ โดยการใช้ Redis เป็นแคชสำหรับจัดเก็บข้อมูลสถานะการเชื่อมต่อ และการส่งข้อมูลในห้องแชทในแบบเรียลไทม์ ด้วย Redis, WebSocket Server สามารถเพิ่มขนาดได้อย่างง่ายดายเมื่อมีการขยายตัวของจำนวนผู้ใช้งาน

ทำไม WebSocket Server ต้องรองรับการสเกล?

ในแอปพลิเคชันที่มีผู้ใช้งานจำนวนมาก WebSocket Server อาจจะต้องรองรับการเชื่อมต่อหลายพันหรือหลายหมื่นคอนเน็กชันพร้อมกัน ซึ่งเป็นการทดสอบประสิทธิภาพของเซิร์ฟเวอร์ในกรณีการใช้งานแบบสเกลสูง ดังนั้นการทำให้ WebSocket Server รองรับการสเกลจะช่วยให้:

• รองรับการเชื่อมต่อที่มากขึ้น: โดยไม่ทำให้ระบบช้าลง
• เพิ่มประสิทธิภาพในการจัดการข้อมูล: ในขณะที่มีการเชื่อมต่อหลายร้อยหรือหลายพัน
• ช่วยเพิ่มความเร็วในการส่งข้อมูล: โดยใช้ Redis ในการเก็บข้อมูลแคชและแชร์ข้อมูลระหว่างหลาย instance ของเซิร์ฟเวอร์

ข้อดีของการรองรับการสเกล:

• สามารถจัดการกับจำนวนการเชื่อมต่อที่สูง: รองรับผู้ใช้จำนวนมากโดยไม่ทำให้เกิดการดีเลย์หรือข้อผิดพลาด
• เพิ่มประสิทธิภาพ: ใช้ Redis เพื่อจัดเก็บข้อมูลที่ต้องใช้ซ้ำในหลายๆ การเชื่อมต่อ
• รองรับการขยายระบบ: สามารถเพิ่ม WebSocket Server เพิ่มเติมได้ง่ายและทำงานร่วมกันได้โดยไม่ต้องปรับแก้โค้ดมาก

โครงสร้างของฟีเจอร์การควบคุมการเข้าถึงห้องแชท

ฟีเจอร์การควบคุมการเข้าถึงห้องแชทจำเป็นต้องมีการตรวจสอบสิทธิ์ของผู้ใช้ในระบบ โดยจะต้องเชื่อมโยงกับข้อมูลผู้ใช้ในฐานข้อมูลและตรวจสอบว่าผู้ใช้คนใดสามารถเข้าร่วมการสนทนาในห้องนั้นได้

ส่วนประกอบหลักของระบบการควบคุมการเข้าถึงห้องแชท:

• การเก็บข้อมูลผู้ใช้ในฐานข้อมูล: ข้อมูลเกี่ยวกับผู้ใช้ เช่น สิทธิ์การเข้าร่วมจะต้องถูกเก็บในฐานข้อมูล
• การตรวจสอบสิทธิ์การเข้าถึง: ระบบจะต้องสามารถตรวจสอบสิทธิ์ของผู้ใช้และอนุมัติหรือปฏิเสธการเข้าร่วม
• การจัดการการเข้าถึงห้องแชท: เมื่อผู้ใช้พยายามเข้าร่วมห้องแชท ระบบจะต้องสามารถอนุมัติหรือปฏิเสธการเข้าร่วมได้ตามสิทธิ์ของผู้ใช้

การทำให้ WebSocket Server รองรับการสเกล (Scalability) ด้วย Redis

การปรับปรุง WebSocket Server ให้รองรับการสเกลด้วย Redis ประกอบไปด้วยขั้นตอนการตั้งค่า Redis และการเชื่อมต่อกับ WebSocket Server เพื่อให้สามารถจัดการกับหลายๆ connection พร้อมกันได้

ขั้นตอนที่ต้องทำ:

1. การติดตั้ง Redis และเชื่อมต่อกับ WebSocket Server: เริ่มต้นด้วยการติดตั้ง Redis และตั้งค่า WebSocket Server ให้สามารถใช้ Redis ในการเก็บข้อมูลสถานะการเชื่อมต่อ
2. การจัดเก็บสถานะการเชื่อมต่อใน Redis: เราจะใช้ Redis สำหรับเก็บข้อมูลสถานะการเชื่อมต่อทั้งหมด รวมถึงการเชื่อมต่อของผู้ใช้ที่เข้าห้องแชท
3. การกระจายข้อมูลระหว่างหลาย WebSocket Servers: เมื่อ WebSocket Server หลายตัวทำงานร่วมกัน Redis จะช่วยให้สามารถกระจายข้อมูลไปยังทุกเซิร์ฟเวอร์ได้โดยไม่ขัดแย้งกัน

การสร้าง UI สำหรับการรองรับการสเกล

การแสดงผล UI จะช่วยให้ผู้ใช้สามารถเห็นการเชื่อมต่อในห้องแชทและประสิทธิภาพของการเชื่อมต่อในระบบ โดยการแสดงสถิติการเชื่อมต่อและข้อมูลที่มีการอัปเดตในทุกๆ ช่วงเวลา

ส่วนประกอบของ UI:

• แสดงจำนวนการเชื่อมต่อที่กำลังทำงานอยู่: UI จะมีการแสดงจำนวนคอนเน็กชันที่กำลังทำงานในระบบ
• แสดงการอัปเดตข้อความที่มีการส่ง: ข้อความที่ถูกส่งไปยังทุกคนในห้องแชทจะถูกแสดงผลทันที
• แสดงสถานะของการเชื่อมต่อ: UI จะแสดงสถานะการเชื่อมต่อที่พร้อมใช้งานในห้องแชท

การทดสอบการรองรับการสเกล

หลังจากเพิ่มฟีเจอร์การรองรับการสเกลแล้ว การทดสอบจะเป็นสิ่งสำคัญเพื่อให้มั่นใจว่าระบบสามารถรองรับการเชื่อมต่อที่มีจำนวนมากได้

การทดสอบที่ควรทำ:

• ทดสอบจำนวนการเชื่อมต่อ: ทดสอบระบบโดยการเชื่อมต่อหลายพันคอนเน็กชันไปยัง WebSocket Server
• ทดสอบการส่งข้อความในหลายๆ instance ของเซิร์ฟเวอร์: ตรวจสอบว่า Redis สามารถช่วยกระจายข้อมูลและการส่งข้อความไปยังหลายๆ เซิร์ฟเวอร์ได้
• ทดสอบการตอบสนองในระบบที่มีการขยายขนาด: ตรวจสอบว่า WebSocket Server สามารถจัดการกับการขยายขนาดของระบบและให้บริการต่อไปได้

ตัวอย่างโค้ดสำหรับการรองรับการสเกลใน WebSocket Chat ด้วย Redis

1. การติดตั้ง Redis (Redis Setup)

ติดตั้ง Redis บนเครื่องหรือเซิร์ฟเวอร์ที่ใช้งาน

sudo apt-get install redis-server

2. โค้ดใน WebSocket Server (Backend)

ใช้ Redis เพื่อเก็บสถานะการเชื่อมต่อ

package main

import (
    "github.com/go-redis/redis/v8"
    "github.com/gorilla/websocket"
    "fmt"
    "net/http"
    "sync"
    "context"
)

var rdb *redis.Client

func init() {
    rdb = redis.NewClient(&redis.Options{
        Addr: "localhost:6379", // Redis server address
    })
}

var (
    clients   = make(map[*websocket.Conn]bool)
    broadcast = make(chan string)
    mu        sync.Mutex
)

func handleConnection(w http.ResponseWriter, r *http.Request) {
    conn, _ := upgrader.Upgrade(w, r, nil)
    defer conn.Close()
    clients[conn] = true

    for {
        var message string
        err := conn.ReadMessage(&message)
        if err != nil {
            delete(clients, conn)
            break
        }

        // Store message in Redis
        rdb.LPush(context.Background(), "chat_messages", message)
        
        broadcast <- message
    }
}

func notifyClients() {
    for {
        msg := <-broadcast
        for client := range clients {
            err := client.WriteMessage(msg)
            if err != nil {
                client.Close()
                delete(clients, client)
            }
        }
    }
}

func main() {
    http.HandleFunc("/ws", handleConnection)
    go notifyClients()
    fmt.Println("WebSocket Server Running on Port 8080")
    http.ListenAndServe(":8080", nil)
}

3. โค้ดใน Frontend (Client)

เพิ่มการเชื่อมต่อกับ Redis เพื่อแสดงข้อความใน UI

const socket = new WebSocket("ws://localhost:8080/ws");
const chatContainer = document.getElementById("chat-container");

socket.onmessage = (event) => {
    const data = event.data;
    const messageElement = document.createElement("p");
    messageElement.innerText = data;
    chatContainer.appendChild(messageElement);
};

function sendMessage(message) {
    socket.send(message);
}

ท้าให้ลอง!

ลองเพิ่ม ระบบการเก็บข้อความใน Redis เพื่อให้สามารถค้นหาข้อความได้เร็วขึ้นและช่วยเพิ่มประสิทธิภาพในการส่งข้อมูล!

EP ถัดไป:
ใน EP ถัดไป เราจะมาดู การเพิ่มฟีเจอร์การแชทแบบกลุ่ม (Group Chat) ใน WebSocket เพื่อทำให้ผู้ใช้สามารถเข้าร่วมแชทกลุ่มได้ และรองรับการส่งข้อความในกลุ่มผ่าน WebSocket!