DocsPricingBlog
Contact Us
Log inSign up for FREE
Back to Tech Articles

GoアプリケーションでのGorilla WebSocketによるリアルタイム通信

Sep 18, 2025
# Misc

Ethan Miller

Product Engineer · Leapcell

This post is also available in English, 한국어, and Deutsch
Cover of "GoアプリケーションでのGorilla WebSocketによるリアルタイム通信"

はじめに：Goアプリケーションへのリアルタイムインタラクティブ機能の追加

今日のペースの速いデジタル世界では、静的なWebページや従来の要求-応答アーキテクチャは、ユーザーの期待に応えられないことがよくあります。チャットプラットフォーム、共同編集ツール、ライブダッシュボード、オンラインゲームなど、現代のアプリケーションは、即時の更新とシームレスな対話によって成長します。このリアルタイム通信への需要により、WebSocketのようなテクノロジーは不可欠になりました。Goは、優れた並行処理プリミティブと堅牢な標準ライブラリを備えており、高性能ネットワークサービスを構築するための理想的な言語です。Goでのリアルタイム通信に関しては、gorilla/websocketライブラリは事実上の標準として際立っています。これは、WebSocketサーバーとクライアントを実装するためのシンプルでありながら強力なAPIを提供し、開発者がGoアプリケーションに動的で双方向の通信機能を簡単に追加できるようにします。この記事では、gorilla/websocketを統合して、サービスのインタラクティビティを新たなレベルに引き上げるプロセスを説明します。

リアルタイム通信とWebSocketの理解

コードを詳しく見る前に、関係するコアコンセプトを明確に理解しましょう。

**リアルタイム通信（RTC）：**これは、伝送遅延なしにユーザーが情報を即座に交換できるあらゆる電気通信媒体を指します。Webコンテキストでは、サーバーはクライアントが定期的にポーリング（問い合わせ）しなくても、利用可能になり次第データをクライアントにプッシュできることを意味します。

**WebSocket：**WebSocketは、単一の長寿命TCP接続を介してフルデュプレックス通信チャネルを提供します。従来のHTTPとは異なり、各要求が新しい接続を開始するのに対し、WebSocketは初期HTTPハンドシェイク後に永続的な接続を確立します。これにより、クライアントとサーバーはいつでも互いにメッセージを送信でき、ポーリングやロングポーリング技術と比較してオーバーヘッドとレイテンシが大幅に削減されます。

**gorilla/websocket：**これは、WebSocketサーバーとクライアントを実装するためのクリーンであいまいなAPIを提供する、人気がありよく維持されているGoライブラリです。ハンドシェイク、フレーミング、制御フレームなどのWebSocketプロトコルの複雑さを処理し、開発者がアプリケーションロジックに焦点を当てられるようにします。

シンプルなWebSocketサーバーの構築

受信したメッセージをそのままエコーバックする基本的なWebSocketサーバーを作成することから始めましょう。これにより、基本的なgorilla/websocketサーバーサイドAPIが実証されます。

package main

import (
	"log"
	"net/http"

	"github.com/gorilla/websocket"
)

// アップグレーダーを設定してWebSocketハンドシェイクを処理します。
// CheckOrigin は、本番環境でのセキュリティにとって重要です。
// デモンストレーションのため、すべてのオリジンを許可します。
var upgrader = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
	CheckOrigin: func(r *http.Request) bool {
		return true // 簡単にするためにすべてのオリジンを許可します。本番環境ではこれを制限してください。
	},
}

// wsHandler はWebSocket接続を処理します。
func wsHandler(w http.ResponseWriter, r *http.Request) {
	// HTTP接続をWebSocket接続にアップグレードします。
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Printf("接続のアップグレードに失敗しました: %v", err)
		return
	}
	defer conn.Close() // ハンドラーが終了するときに接続が閉じられることを保証します。

	log.Println("クライアントが接続しました:", r.RemoteAddr)

	for {
		// クライアントからメッセージを読み取ります。
		messageType, p, err := conn.ReadMessage()
		if err != nil {
			log.Printf("%sからメッセージの読み取り中にエラーが発生しました: %v", r.RemoteAddr, err)
			break // エラー（例：クライアントが切断）が発生したらループを終了します。
		}

		log.Printf("%sから受信したメッセージ: %s", r.RemoteAddr, p)

		// 同じメッセージをクライアントに書き戻します。
		if err := conn.WriteMessage(messageType, p); err != nil {
			log.Printf("%sへのメッセージの書き込み中にエラーが発生しました: %v", r.RemoteAddr, err)
			break // エラーが発生したらループを終了します。
		}
	}

	log.Println("クライアントが切断しました:", r.RemoteAddr)
}

func main() {
	http.HandleFunc("/ws", wsHandler) // WebSocketハンドラーを登録します。

	log.Println("WebSocketサーバーが:8080で起動します")
	err := http.ListenAndServe(":8080", nil) // HTTPサーバーを起動します。
	if err != nil {
		log.Fatalf("サーバーの起動に失敗しました: %v", err)
	}
}

説明：

  1. **upgrader：**このグローバル変数は、HTTP接続がWebSocketにアップグレードされる方法を構成します。ReadBufferSizeとWriteBufferSizeはバッファーサイズを決定します。CheckOriginはセキュリティにとって重要であり、実際のアプリケーションでは通常、クロスサイトWebSocketハイジャックを防ぐためにOriginヘッダーを検証します。
  2. wsHandler：
    • upgrader.Upgrade(w, r, nil)：これはWebSocketハンドシェイクを実行するコア呼び出しです。成功すると、確立されたWebSocket接続を表すwebsocket.Connオブジェクトが返されます。
    • defer conn.Close()：関数が終了するときに接続が適切に閉じられ、リソースが解放されることを保証します。
    • for {}ループは、メッセージの読み取りと書き込みを継続的に行います。
    • conn.ReadMessage()：受信したメッセージを読み取ります。メッセージタイプ（例：websocket.TextMessage、websocket.BinaryMessage）、メッセージペイロード（[]byte）、およびエラーを返します。
    • conn.WriteMessage(messageType, p)：クライアントにメッセージを書き戻します。ここでは、受信したメッセージを単にエコーバックしています。
    • ReadMessageおよびWriteMessageのエラー処理は、クライアントの切断やネットワークの問題を検出するために不可欠です。

シンプルなWebSocketクライアントの構築（Goで）

通常、WebSocketサーバーに接続するためにブラウザのJavaScript API（例：new WebSocket('ws://localhost:8080/ws')）を使用しますが、gorilla/websocketはクライアントサイドの機能も提供します。サーバーをテストするためにGoクライアントを作成しましょう。

package main

import (
	"fmt"
	"log"
	"net/url"
	"os"
	"os/signal"
	"time"

	"github.com/gorilla/websocket"
)

func main() {
	interrupt := make(chan os.Signal, 1)
	signal.Notify(interrupt, os.Interrupt)

	u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/ws"}
	log.Printf("接続中 %s", u.String())

	conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
	if err != nil {
		log.Fatal("Dial:", err)
	}
	defer conn.Close()

	done := make(chan struct{})

	// サーバーからのメッセージを読み取るゴルーチン
	go func() {
		defer close(done)
		for {
			_, message, err := conn.ReadMessage()
			if err != nil {
				log.Println("Read error:", err)
				return
			}
			log.Printf("サーバーから受信: %s", message)
		}
	}()

	// サーバーにメッセージを送信するゴルーチン
	ticker := time.NewTicker(time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-done: // サーバー接続が閉じられました
			return
		case t := <-ticker.C: // 1秒ごとにメッセージを送信
			message := fmt.Sprintf("Hello from client at %s", t.Format(time.RFC3339))
			err := conn.WriteMessage(websocket.TextMessage, []byte(message))
			if err != nil {
				log.Println("Write error:", err)
				return
			}
		case <-interrupt: // OS割り込み (Ctrl+C)
			log.Println("割り込みシグナルを受信しました。接続を閉じます...")
			err := conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
			if err != nil {
				log.Println("Write close error:", err)
				return
			}
			select {
			case <-done:
			case <-time.After(time.Second): // サーバーが閉じるのを待つか、タイムアウトする
			}
			return
		}
	}
}

説明：

  1. **websocket.DefaultDialer.Dial：**指定されたURLにクライアントサイドのWebSocket接続を確立します。
  2. **doneチャネル：**読み取りルーチンが停止したときに（通常はサーバーが接続を閉じたか、エラーが発生した場合）サインを送信するために使用されます。
  3. 読み取りゴルーチン： サーバーからメッセージを継続的に読み取り、表示します。
  4. 書き込みゴルーチン（またはtickerを使用したメインループ）： conn.WriteMessageを使用して1秒ごとにサーバーにメッセージを送信します。
  5. interruptチャネル： Ctrl+Cを正常に処理し、WebSocket接続を閉じるメッセージとともに閉じ、サーバーに通知します。

高度な概念とアプリケーションシナリオ

複数の接続の管理（チャットアプリケーションの例）

実際のWebSocketアプリケーションでは、複数の接続クライアントを管理する必要があります。「ハブ」または「マネージャー」があり、すべてのアクティブな接続を追跡し、メッセージをブロードキャストする一般的なパターンです。

チャットアプリケーションで、あるクライアントからのメッセージが他のすべての接続クライアントにブロードキャストされるように、サーバーをリファクタリングしてみましょう。

package main

import (
	"log"
	"net/http"
	"sync"
	"time"

	"github.com/gorilla/websocket"
)

// Clientは単一のWebSocketクライアント接続を表します。
type Client struct {
	conn *websocket.Conn
	mu   sync.Mutex // 接続への書き込みを保護するためのミューテックス
}

// HubはWebSocket接続を管理します。
type Hub struct {
	clients    map[*Client]bool // 登録済みクライアント
	register   chan *Client     // クライアントからの登録要求
	unregister chan *Client     // クライアントからの登録解除要求
	broadcast  chan []byte      // クライアントからブロードキャストへの受信メッセージ
}

// NewHubは新しいHubインスタンスを作成します。
func NewHub() *Hub {
	return &Hub{
		broadcast:  make(chan []byte),
		register:   make(chan *Client),
		unregister: make(chan *Client),
		clients:    make(map[*Client]bool),
	}
}

// Runはハブの操作を開始します。
func (h *Hub) Run() {
	for {
		select {
		case client := <-h.register:
			h.clients[client] = true
			log.Printf("クライアント登録済み: %s (合計: %d)", client.conn.RemoteAddr(), len(h.clients))
		case client := <-h.unregister:
			if _, ok := h.clients[client]; ok {
				delete(h.clients, client)
				client.conn.Close()
				log.Printf("クライアント登録解除済み: %s (合計: %d)", client.conn.RemoteAddr(), len(h.clients))
			}
		case message := <-h.broadcast:
			for client := range h.clients {
				client.mu.Lock() // このクライアントに対する一度の書き込み操作のみを保証します
				err := client.conn.WriteMessage(websocket.TextMessage, message)
				client.mu.Unlock()
				if err != nil {
					log.Printf("クライアント %s へのメッセージ送信中にエラーが発生しました: %v", client.conn.RemoteAddr(), err)
					client.conn.Close()
					delete(h.clients, client) // 送信に失敗した場合はクライアントを削除します
				}
			}
		}
	}
}

var upgrader = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
	CheckOrigin: func(r *http.Request) bool { return true },
}

// ServeWsはピアからのWebSocket要求を処理します。
func ServeWs(hub *Hub, w http.ResponseWriter, r *http.Request) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Printf("接続のアップグレードに失敗しました: %v", err)
		return
	}

	client := &Client{conn: conn}
	hub.register <- client // 新しいクライアントを登録します

	// 古いメッセージの収集を許可し、Websocket送信バッファーを
	// 満たすメッセージが多すぎるのを防ぎます。
	go client.writePump(hub)
	go client.readPump(hub)
}

// readPumpはWebSocket接続からハブへメッセージをポンプします。
func (c *Client) readPump(hub *Hub) {
	defer func() {
		hub.unregister <- c // 終了時に登録解除します
		c.conn.Close()
	}()
	c.conn.SetReadLimit(512) // 最大メッセージサイズ
	c.conn.SetReadDeadline(time.Now().Add(60 * time.Second)) // ポンメッセージのデッドラインを設定します
	c.conn.SetPongHandler(func(string) error {
		c.conn.SetReadDeadline(time.Now().Add(60 * time.Second)) // ポン時にデッドラインをリセットします
		return nil
	})

	for {
		_, message, err := c.conn.ReadMessage()
		if err != nil {
			if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
				log.Printf("クライアント %s からの読み取り中にエラー: %v", c.conn.RemoteAddr(), err)
			}
			break
		}
		hub.broadcast <- message // ブロードキャストのためにハブにメッセージを送信します
	}
}

// writePumpはハブからWebSocket接続へメッセージをポンプします。
func (c *Client) writePump(hub *Hub) {
	ticker := time.NewTicker(50 * time.Second) // 定期的にpingを送信します
	defer func() {
		ticker.Stop()
		c.conn.Close()
	}()
	for {
		select {
		case message, ok := <-hub.broadcast: // これは単純なもので、実際のチャットではこのクライアント専用のメッセージを送信します
			if !ok {
				// ハブがブロードキャストチャネルを閉じました。
				c.mu.Lock()
				c.conn.WriteMessage(websocket.CloseMessage, []byte{})
				c.mu.Unlock()
				return
			}
			c.mu.Lock()
			err := c.conn.WriteMessage(websocket.TextMessage, message)
			c.mu.Unlock()
			if err != nil {
				log.Printf("クライアント %s へのメッセージ書き込み中にエラー: %v", c.conn.RemoteAddr(), err)
				return // writePumpを終了します
			}
		case <-ticker.C:
			// 接続を維持するために、クライアントにpingメッセージを送信します。
			c.mu.Lock()
			err := c.conn.WriteMessage(websocket.PingMessage, nil)
			c.mu.Unlock()
			if err != nil {
				log.Printf("クライアント %s へのPingエラー: %v", c.conn.RemoteAddr(), err)
				return // writePumpを終了します
			}
		}
	}
}

func main() {
	hub := NewHub()
	go hub.Run() // ハブをゴルーチンで起動します

	http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
		ServeWs(hub, w, r)
	})

	log.Println("チャットサーバーが:8080で起動します")
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		log.Fatalf("サーバーの起動に失敗しました: %v", err)
	}
}

チャット例での主な追加点：

  1. Client構造体： websocket.Connと、単一接続へのスレッドセーフな書き込みを保証するためのsync.Mutexをカプセル化します。
  2. Hub構造体：
    • clients：すべてのアクティブなClientインスタンスを格納するためのマップ。
    • register、unregister、broadcast：クライアントとハブ間の非同期通信に使用されるチャネル。これにより、ハブ操作（クライアントの追加/削除、ブロードキャスト）が同期され、スレッドセーフになります。
  3. **Hub.Run()：**独自のゴルーチンで実行され、register、unregister、broadcastチャネルを継続的に監視し、受信したリクエストを処理します。
  4. readPumpとwritePump：
    • 各クライアントには、専用のreadPumpとwritePumpゴルーチンが割り当てられます。
    • readPump：クライアントからメッセージを読み取り、hub.broadcastチャネルに送信します。また、キープアライブのための読み取りデッドラインとポンメッセージの設定も処理します。
    • writePump：hub.broadcastチャネルからクライアントへメッセージを送信します。また、無応答のピアを検出するために、クライアントに定期的にpingメッセージを送信します。
  5. **並行処理と同期：**チャネルの使用とClient接続へのsync.Mutexは、競合状態なしに複数のクライアントを同時に処理するために不可欠です。

エラー処理と正常なシャットダウン

例では、基本的なエラー処理（エラーのログ記録、接続の問題でのループの終了）を示しています。本番環境では、より堅牢なエラー回復、潜在的な再試行、および包括的なログ記録が必要になります。クライアントのos.Interruptで示されているような正常なシャットダウンは、リソースをクリーンに解放するために不可欠です。

キープアライブのためのPing/Pong

WebSocketは、接続を維持し、応答しないピアを検出するために、ping/pongフレームが組み込まれています。チャットサーバーの例には、readPumpでSetReadDeadlineとSetPongHandlerが含まれており、一定時間内にポンを期待し、writePumpでPingMessageを送信するためのtickerが含まれています。

セキュリティに関する考慮事項

  • **CheckOrigin：**クロスサイトWebSocketハイジャックを防ぐために、本番環境では常にOriginヘッダーを厳格に検証してください。
  • **認証/認可：**既存の認証システム（例：初期HTTPハンドシェイクでのJWT）と統合して、承認されたユーザーのみがWebSocket接続を確立できるようにします。
  • **入力検証：**クライアントから受信したすべてのメッセージをサニタイズおよび検証して、インジェクション攻撃や不正なデータの問題を防ぎます。
  • **レート制限：**個々のクライアントからのメッセージレートを制限することにより、サービス拒否攻撃からサーバーを保護します。

デプロイメント

リバースプロキシ（NginxまたはCaddyなど）の後ろでGo WebSocketサーバーをデプロイする場合、プロキシがWebSocketアップグレードと永続接続を正しく処理するように設定されていることを確認してください。これには通常、特定のヘッダー構成（Upgrade: websocket、Connection: upgrade）が含まれます。

結論：インタラクティブなGoアプリケーションの強化

gorilla/websocketライブラリを使用すると、Goアプリケーションにリアルタイム通信を簡単かつ効率的に追加できます。WebSocketのコアコンセプト、および同時クライアント管理のためのGoroutineとチャネルを活用することで、優れたユーザーエクスペリエンスを提供する強力でインタラクティブなサービスを構築できます。シンプルなエコーサーバーから複雑なチャットアプリケーションまで、gorilla/websocketは、Goアプリケーションに即時双方向データ交換で命を吹き込むための堅牢な基盤を提供します。このライブラリを採用して、静的な対話を動的なリアルタイムエクスペリエンスに変換してください。

Share this article

HackerNews

More Posts from Leapcell

Popular Posts