# ฟีเจอร์เรียลไทม์สำหรับแบ็กเอนด์ Go โดยไม่ต้องดูแลเซิร์ฟเวอร์ WebSocket เอง

> ส่งอีเวนต์แบบเรียลไทม์ อนุญาตช่อง private และ presence และตรวจเว็บฮุกจาก Go ด้วยไลบรารี pusher-http-go อย่างเป็นทางการ ส่วนเบราว์เซอร์เชื่อมต่อกับ Hibira

Source: https://hibira.io/th/blog/go-backend-realtime
Updated: 2026-11-20

Go เป็นภาษาที่เหมาะกับการเขียนเซิร์ฟเวอร์ WebSocket หลายทีมจึงคิดจะสร้างเองเป็นอย่างแรก มี hub หนึ่งตัว ใช้ goroutine ดูแลแต่ละการเชื่อมต่อ และกระจายข้อความเมื่อมีอีเวนต์เข้ามา บนเครื่องเดียววิธีนี้ทำงานได้ดี แต่เมื่อต้องรันสองเครื่องขึ้นไป ทำ presence (ใครออนไลน์อยู่) และรับมือกับการเชื่อมต่อใหม่และการย้ายการเชื่อมต่อระหว่าง deploy WebSocket ก็ไม่ใช่แค่ฟีเจอร์อีกต่อไป แต่กลายเป็นระบบที่ต้องดูแล

อีกทางหนึ่งคือให้แบ็กเอนด์ Go ตัดสินใจแค่ว่าจะส่งอะไร แล้วปล่อยงานรักษาการเชื่อมต่อนับหมื่นให้บริการแบบโฮสต์ Hibira ใช้โปรโตคอล Pusher Channels คุณจึงใช้ไลบรารี Go อย่างเป็นทางการของ Pusher อย่าง [pusher-http-go](https://github.com/pusher/pusher-http-go) ได้ทันที และใช้ pusher-js ในเบราว์เซอร์ บทความนี้พาไปดูห้าเรื่อง ได้แก่ การสร้างไคลเอนต์ การส่งอีเวนต์ การอนุญาตช่อง private และ presence การเชื่อมต่อฝั่งหน้าเว็บ และการรับเว็บฮุก

```text
flow: แบ็กเอนด์ Go ส่งผ่าน HTTP เบราว์เซอร์รับผ่าน WebSocket
บริการ Go ของคุณ --HTTP API--> *Hibira|ws.hibira.io --WebSocket--> เบราว์เซอร์และแอป
เบราว์เซอร์และแอป --เมื่อสมัครช่อง private--> /pusher/auth|บริการ Go ของคุณ
*Hibira --เว็บฮุก--> /pusher/webhook|บริการ Go ของคุณ
```

## ขั้นที่ 1: ติดตั้งและสร้างไคลเอนต์

```shell
go get github.com/pusher/pusher-http-go/v5
```

สร้างไคลเอนต์หนึ่งตัวตอนเริ่มทำงาน โดยอ่าน App ID, key และ secret จากตัวแปรสภาพแวดล้อม (จะเห็นค่าเหล่านี้เมื่อ[สร้างแอป](https://hibira.io/signup)แล้ว) จากนั้นส่งต่อให้ handler หรือ service ที่ต้องส่งอีเวนต์

```go
import pusher "github.com/pusher/pusher-http-go/v5"

func newRealtime() *pusher.Client {
	return &pusher.Client{
		AppID:  os.Getenv("HIBIRA_APP_ID"),
		Key:    os.Getenv("HIBIRA_APP_KEY"),
		Secret: os.Getenv("HIBIRA_APP_SECRET"),
		Host:   "ws.hibira.io",
		Secure: true,
		// ตั้งค่าไว้ตอนเริ่มทำงาน แทนที่จะปล่อยให้ไลบรารีสร้างเองในคำขอแรก
		HTTPClient: &http.Client{Timeout: 3 * time.Second},
	}
}
```

บรรทัด `HTTPClient` มีเหตุผล ถ้าไม่ตั้งไว้ pusher-http-go จะสร้าง `http.Client` ที่หมดเวลา 5 วินาทีในคำขอแรก แล้วเขียนกลับไปที่ไคลเอนต์ ถ้าหลาย goroutine ส่งครั้งแรกพร้อมกัน นี่คือ data race และ `go test -race` จะจับได้ ตั้งเองตอนเริ่มทำงาน และปรับเวลาหมดให้เหมาะกับบริการของคุณไปด้วย

## ขั้นที่ 2: ส่งอีเวนต์

การส่งคือการเรียก HTTP หนึ่งครั้ง ยกตัวอย่างคำสั่งซื้อที่จัดส่งแล้ว

```go
func shipOrder(rt *pusher.Client, w http.ResponseWriter, r *http.Request) {
	order := Order{ID: 1024, Status: "shipped"}
	// … เขียนสถานะคำสั่งซื้อลงฐานข้อมูลก่อน …

	socketID := r.Header.Get("X-Socket-ID") // ส่งมาจากฝั่งหน้าเว็บ อาจว่างได้
	if err := rt.TriggerExclusive("private-user-42", "order-updated", order, socketID); err != nil {
		log.Printf("realtime: %v", err) // ส่งไม่สำเร็จก็ไม่ยกเลิกคำสั่งซื้อ
	}
	json.NewEncoder(w).Encode(order)
}
```

ข้อแนะนำจากการใช้งานจริง

- **เขียนฐานข้อมูลก่อน แล้วจึงส่ง** อีเวนต์แบบเรียลไทม์เป็นการแจ้งเตือน ไม่ใช่แหล่งข้อมูลจริง ไคลเอนต์ที่เชื่อมต่อใหม่ควรโหลดจาก API อีกครั้ง แทนที่จะพึ่งอีเวนต์ที่อาจพลาดไป
- **ไม่ส่งกลับไปหาผู้เริ่ม** ส่ง socket ID ของหน้าเว็บให้ `TriggerExclusive` แล้วแท็บที่ทำการเปลี่ยนแปลงจะไม่ได้รับอัปเดตของตัวเองซ้ำ ถ้าต้องการส่งถึงทุกคน ใช้ `Trigger` ธรรมดาก็พอ
- **ส่งหลายรายการในครั้งเดียว** เมื่อคำขอเดียวต้องอัปเดตหลายช่อง ใช้ `TriggerMulti` (อีเวนต์เดียวไปหลายช่อง) หรือ `TriggerBatch` (อีเวนต์ต่างกัน) เพื่อลดจำนวนรอบ
- **อย่าให้คำขอต้องรอ** ถ้าการส่งอยู่บนเส้นทางที่ไวต่อความหน่วง ให้ส่งต่อไปที่ goroutine เบื้องหลังหรือคิวงาน แต่ยังต้องจัดการข้อผิดพลาดและเคลียร์งานที่ค้างตอนปิดบริการ

**ข้อควรระวังด้านความปลอดภัย:** `X-Socket-ID` เป็นเพียงค่าที่ใช้ป้องกันการส่งอีเวนต์กลับไปยังแท็บต้นทาง ไม่ใช่หลักฐานยืนยันตัวตน การอนุญาตเข้าช่องต้องอ้างอิงเซสชันหรือ JWT ที่เซิร์ฟเวอร์ตรวจสอบแล้ว และต้องตรวจสอบรูปแบบฟอร์มกับขนาดคำขอโดยไม่ตัดข้อมูลทิ้งเงียบ ๆ

## ขั้นที่ 3: อนุญาตช่อง private และ presence

ก่อนสมัครช่องที่ขึ้นต้นด้วย `private-` หรือ `presence-` ไคลเอนต์จะขอลายเซ็นจากเซิร์ฟเวอร์ของคุณ บริการ Go ของคุณเป็นผู้ให้ endpoint นี้ ดังนั้นใครดูช่องไหนได้จึงขึ้นอยู่กับโค้ดของคุณทั้งหมด

```go
func pusherAuth(rt *pusher.Client) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		user, ok := currentUser(r) // การตรวจ session หรือ JWT ของคุณเอง
		if !ok {
			http.Error(w, "unauthorized", http.StatusUnauthorized)
			return
		}
		body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 4096))
		if err != nil {
			http.Error(w, "bad request", http.StatusBadRequest)
			return
		}
		form, err := url.ParseQuery(string(body))
		if err != nil {
			http.Error(w, "bad request", http.StatusBadRequest)
			return
		}
		channel := form.Get("channel_name")
		if (!strings.HasPrefix(channel, "private-") && !strings.HasPrefix(channel, "presence-")) || !user.CanJoin(channel) {
			http.Error(w, "forbidden", http.StatusForbidden)
			return
		}

		var resp []byte
		if strings.HasPrefix(channel, "presence-") {
			resp, err = rt.AuthorizePresenceChannel(body, pusher.MemberData{
				UserID:   user.ID,
				UserInfo: map[string]string{"name": user.Name},
			})
		} else {
			resp, err = rt.AuthorizePrivateChannel(body)
		}
		if err != nil {
			http.Error(w, "forbidden", http.StatusForbidden)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		w.Write(resp)
	}
}
```

ไลบรารีทำแค่ลงลายเซ็น ไม่ได้ตรวจสิทธิ์ คุณจึงต้องเขียนขั้น `CanJoin` เองเสมอ ข้อผิดพลาดที่พบบ่อยคือตรวจแค่ว่าล็อกอินแล้วหรือยัง ซึ่งทำให้ผู้ใช้ที่ล็อกอินคนไหนก็สมัคร `private-user-42` ได้ ส่วน `UserInfo` ของช่อง presence จะถูกส่งไปให้สมาชิกทุกคนในช่อง ใส่เฉพาะข้อมูลที่เปิดเผยได้

ต่อทั้งสาม endpoint ด้วยรูปแบบของ `http.ServeMux` ตั้งแต่ Go 1.22

```go
rt := newRealtime()
mux := http.NewServeMux()
mux.HandleFunc("POST /orders/{id}/ship", func(w http.ResponseWriter, r *http.Request) { shipOrder(rt, w, r) })
mux.HandleFunc("POST /pusher/auth", pusherAuth(rt))
mux.HandleFunc("POST /pusher/webhook", pusherWebhook(rt))
log.Fatal(http.ListenAndServe(":8080", mux))
```

## ขั้นที่ 4: เชื่อมต่อฝั่งหน้าเว็บ

ในเบราว์เซอร์ ชี้โฮสต์ของ pusher-js ไปที่ Hibira และชี้ endpoint การอนุญาตไปที่บริการ Go ของคุณ

```js
import Pusher from 'pusher-js';

const pusher = new Pusher('your-app-key', {
  cluster: 'hkg',
  wsHost: 'ws.hibira.io',
  wsPort: 443,
  wssPort: 443,
  forceTLS: true,
  enabledTransports: ['ws', 'wss'],
  channelAuthorization: { endpoint: '/pusher/auth', transport: 'ajax' },
});

pusher.subscribe('private-user-42').bind('order-updated', (order) => {
  renderOrder(order);
});

// ส่ง socket ID ไปกับการเรียก API ของคุณ เพื่อให้เซิร์ฟเวอร์ข้ามแท็บนี้
await fetch('/orders/1024/ship', {
  method: 'POST',
  headers: { 'X-Socket-ID': pusher.connection.socket_id },
});
```

คำขออนุญาตจะแนบคุกกี้ของเบราว์เซอร์ไปด้วย ถ้าหน้าเว็บกับบริการ Go อยู่โดเมนเดียวกัน session ที่มีอยู่ก็ใช้ได้เลย ถ้าใช้ JWT ให้เพิ่มเฮดเดอร์ `Authorization` ใน `channelAuthorization.headers` แอปมือถือก็เหมือนกัน ทั้ง PusherSwift และ pusher-java-client ตั้งค่าโฮสต์และ endpoint การอนุญาตได้

## ขั้นที่ 5: รับเว็บฮุก

ถ้าอยากรู้ว่าช่องมีผู้สมัครคนแรกเมื่อไร หรือใครเข้าหรือออกจากช่อง presence ให้ตั้ง URL เว็บฮุกในหน้าแอป pusher-http-go จะตรวจเฮดเดอร์ `X-Pusher-Key` และลายเซ็น HMAC ให้

```go
func pusherWebhook(rt *pusher.Client) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 1<<20))
		if err != nil {
			http.Error(w, "bad request", http.StatusBadRequest)
			return
		}
		hook, err := rt.Webhook(r.Header, body) // ตรวจ X-Pusher-Key และลายเซ็น
		if err != nil {
			http.Error(w, "invalid signature", http.StatusUnauthorized)
			return
		}
		for _, e := range hook.Events {
			switch e.Name {
			case "member_added":
				markOnline(e.UserID)
			case "member_removed":
				markOffline(e.UserID)
			}
		}
		w.WriteHeader(http.StatusOK)
	}
}
```

เว็บฮุกจะรวมอีเวนต์ในช่วงเวลาสั้น ๆ เป็นคำขอเดียว ถ้า endpoint ของคุณไม่ตอบ 2xx Hibira จะลองส่งใหม่นานสูงสุดห้านาที การประมวลผลจึงต้องเป็น idempotent คือได้รับ `member_added` เดิมสองครั้งแล้วผลต้องเหมือนเดิม ถ้าประมวลผลนาน ให้ตอบ 200 ก่อนแล้วส่งงานต่อให้งานเบื้องหลัง

## ตรวจก่อนขึ้นระบบจริง

- รันโค้ดที่ส่งอีเวนต์ด้วย `go test -race` แล้ว
- การอนุญาตช่อง private ตรวจว่าผู้ใช้คนนี้ดูช่องนี้ได้หรือไม่ ไม่ใช่แค่ล็อกอินแล้วหรือยัง
- App secret อยู่แค่ในตัวแปรสภาพแวดล้อมหรือบริการจัดการความลับ ไม่อยู่ใน version control หรือโค้ดฝั่งหน้าเว็บ
- ในคอนโซลดีบักของหน้าแอป ตรวจแล้วว่าอีเวนต์ที่ส่ง การสมัคร และเว็บฮุกแสดงขึ้นมา

การตั้งค่าพื้นฐานของ Go มีอยู่ใน[คู่มือเชื่อมต่อ Go](https://hibira.io/th/guides/go) ด้วย และเมื่อเปิดจากหน้าแอป โฮสต์ของคุณจะถูกกรอกให้อัตโนมัติ ถ้าต้องการการแจ้งเตือนแบบพุช [คู่มือการแจ้งเตือนแบบพุช](https://hibira.io/th/guides/push-notifications)มีตัวอย่าง Go สำหรับสถานการณ์เต็มรูปแบบ ดู[การติดตามคำสั่งซื้อ](https://hibira.io/th/use-cases/order-tracking)และ[การทำงานร่วมกันและสถานะออนไลน์](https://hibira.io/th/use-cases/collaboration-presence) ถ้าคุณเขียนโค้ดด้วย Claude Code หรือผู้ช่วย AI อื่น ก็ให้มันดึงคู่มือเชื่อมต่อ Go ผ่าน [เซิร์ฟเวอร์ MCP ของ Hibira](https://hibira.io/th/mcp-server) แล้วแก้โปรเจกต์ให้คุณได้เลย
