ใน EP.69 นี้เราจะพูดถึงการใช้ gRPC ในการพัฒนา API สำหรับ WebSocket Chat เพื่อเพิ่มประสิทธิภาพในการสื่อสารระหว่าง WebSocket Server และ Client. gRPC เป็นเฟรมเวิร์กที่พัฒนาโดย Google ซึ่งใช้ Protocol Buffers (protobuf) ในการทำงาน ซึ่งทำให้การสื่อสารมีความเร็วและประสิทธิภาพสูงกว่าการใช้ REST API แบบเดิม.

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

ทำไมต้องใช้ gRPC ใน WebSocket Chat?

gRPC มีหลายข้อดีที่ช่วยให้การพัฒนา WebSocket Chat ทำได้ง่ายขึ้นและมีประสิทธิภาพสูงขึ้น:

1. ประสิทธิภาพสูง: เนื่องจาก gRPC ใช้ Protocol Buffers ซึ่งเป็นรูปแบบบันทึกข้อมูลที่มีขนาดเล็กและบีบอัดได้ดีกว่า JSON ที่ใช้ใน REST API
2. การสื่อสารแบบเรียลไทม์: รองรับการส่งข้อมูลแบบ bidirectional streaming ซึ่งเหมาะสำหรับการส่งข้อความแบบเรียลไทม์ใน WebSocket
3. ลดความหน่วง: gRPC ถูกออกแบบมาให้มี latency ต่ำ และ throughput สูง, เหมาะสำหรับแอปพลิเคชันที่ต้องการความเร็วในการสื่อสาร
4. รองรับหลายภาษา: gRPC รองรับหลายภาษา ซึ่งทำให้สามารถพัฒนาเซิร์ฟเวอร์และไคลเอนต์ในหลายภาษาได้อย่างง่ายดาย
5. ความปลอดภัย: gRPC มีการเข้ารหัส SSL/TLS ในตัว, ซึ่งทำให้การสื่อสารมีความปลอดภัยสูง

การสร้าง API ด้วย gRPC สำหรับ WebSocket Chat

ในส่วนนี้เราจะสร้าง gRPC API สำหรับ WebSocket Chat เพื่อให้สามารถส่งข้อความและข้อมูลต่างๆ ระหว่าง Server และ Client.

1. สร้างไฟล์ .proto สำหรับกำหนด API

เราจะเริ่มต้นด้วยการสร้างไฟล์ .proto ที่จะใช้ในการกำหนด service และ message types ในการสื่อสารระหว่าง Server และ Client.

chat.proto:

syntax = "proto3";

package chat;

service ChatService {
    rpc SendMessage (MessageRequest) returns (MessageResponse);
    rpc ReceiveMessages (MessageRequest) returns (stream MessageResponse);
}

message MessageRequest {
    string user = 1;
    string message = 2;
}

message MessageResponse {
    string user = 1;
    string message = 2;
    string timestamp = 3;
}

2. การสร้างโค้ด Server ด้วย gRPC

หลังจากที่สร้างไฟล์ .proto แล้ว ให้ใช้คำสั่ง protoc เพื่อสร้างโค้ด gRPC server:

protoc --go_out=plugins=grpc:. chat.proto

ตอนนี้เราจะสร้าง gRPC Server ที่รองรับการส่งและรับข้อความ:

server.go:

package main

import (
    "fmt"
    "log"
    "net"
    "google.golang.org/grpc"
    pb "path/to/generated/proto"
    "context"
)

type server struct{}

func (s *server) SendMessage(ctx context.Context, in *pb.MessageRequest) (*pb.MessageResponse, error) {
    return &pb.MessageResponse{
        User:     in.User,
        Message:  in.Message,
        Timestamp: fmt.Sprintf("%v", time.Now()),
    }, nil
}

func (s *server) ReceiveMessages(in *pb.MessageRequest, stream pb.ChatService_ReceiveMessagesServer) error {
    for {
        time.Sleep(1 * time.Second)
        err := stream.Send(&pb.MessageResponse{
            User:    "Server",
            Message: "Hello, " + in.User,
            Timestamp: fmt.Sprintf("%v", time.Now()),
        })
        if err != nil {
            return err
        }
    }
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterChatServiceServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

3. การสร้าง WebSocket Client สำหรับ gRPC

ตอนนี้เราจะสร้าง Client ที่เชื่อมต่อกับ gRPC Server เพื่อส่งและรับข้อมูล:

client.go:

package main

import (
    "fmt"
    "log"
    "google.golang.org/grpc"
    pb "path/to/generated/proto"
    "context"
)

func main() {
    conn, err := grpc.Dial(":50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("Did not connect: %v", err)
    }
    defer conn.Close()

    c := pb.NewChatServiceClient(conn)

    // SendMessage Example
    resp, err := c.SendMessage(context.Background(), &pb.MessageRequest{User: "John", Message: "Hello!"})
    if err != nil {
        log.Fatalf("Could not send message: %v", err)
    }
    fmt.Println("Message Response:", resp.Message)

    // ReceiveMessages Example
    stream, err := c.ReceiveMessages(context.Background(), &pb.MessageRequest{User: "John"})
    if err != nil {
        log.Fatalf("Could not receive messages: %v", err)
    }

    for {
        msg, err := stream.Recv()
        if err != nil {
            log.Fatalf("Error receiving message: %v", err)
        }
        fmt.Println("Received Message:", msg.Message)
    }
}

การทดสอบ gRPC API

หลังจากการพัฒนาแล้ว การทดสอบ gRPC API เป็นสิ่งสำคัญที่ต้องทำ:

1. ทดสอบการส่งข้อความ: ทดสอบว่า Client สามารถส่งข้อความไปยัง Server ได้และได้รับการตอบกลับอย่างถูกต้อง
2. ทดสอบการรับข้อความ: ทดสอบว่า Server สามารถส่งข้อมูลไปยัง Client ได้อย่างต่อเนื่องและไม่มีข้อผิดพลาด
3. ทดสอบประสิทธิภาพ: ทดสอบเวลาในการส่งและรับข้อมูลโดยใช้ gRPC และเปรียบเทียบกับการใช้ REST API แบบเดิม

ท้าให้ลอง!

ลองเพิ่ม Authentication ด้วย JWT ในการเชื่อมต่อ gRPC เพื่อเพิ่มความปลอดภัยให้กับระบบ WebSocket Chat ของคุณ!

EP ถัดไป:

ใน EP.70 เราจะมาดู การปรับปรุงประสิทธิภาพ WebSocket Server ด้วยการใช้ Load Balancer เพื่อเพิ่มความสามารถในการรองรับการเชื่อมต่อจำนวนมากและกระจายโหลดได้อย่างมีประสิทธิภาพ!