はじめに

WebSocketを使ったリアルタイム通信サービスの負荷テストは、通常のHTTP APIとは異なる実装が必要です。この記事では、k6を使ってWebSocketサービスの負荷テストを実装する方法を、実際のプロダクション環境で運用している実装を基に解説します。

特に以下のトピックにフォーカスします：

WebSocketの接続とメッセージング
バイナリデータの送信
状態管理とタイミング制御
メトリクス収集
CI/CDパイプラインへの統合

なぜk6を選んだのか

WebSocket負荷テストツールの選定では、以下の要件を満たす必要がありました：

WebSocketサポート: 双方向通信とバイナリデータ送信が可能
CI/CD統合: GitHub Actionsでの自動実行が容易
メトリクス収集: 詳細なパフォーマンス測定とカスタムメトリクス
スクリプタビリティ: TypeScriptで柔軟にテストシナリオを記述

k6はこれらすべてを満たし、コードベースでテストシナリオを管理できる点が大きな利点でした。

k6の基本構造

k6のスクリプトは以下の4つのライフサイクルで構成されます：

// 1. init段階: 全VUで共有されるデータの初期化
const sharedData = new SharedArray("data", () => {
  return JSON.parse(open("data.json"));
});

// 2. setup段階: テスト開始前の準備（1回のみ実行）
export function setup() {
  // 認証トークンの取得など
  return { timestamp: Date.now() };
}

// 3. VU段階: 各仮想ユーザーが実行するメインロジック
export default function (data) {
  // WebSocket接続やリクエスト送信
}

// 4. teardown段階: テスト終了後のクリーンアップ（1回のみ実行）
export function teardown(data) {
  console.log("Test completed");
}

SharedArrayによる効率的なデータ共有

k6では、各VU（Virtual User）が独立したJavaScriptランタイムを持ちます。そのため、大きなバイナリファイルなどを各VUで個別に読み込むとメモリを大量に消費します。

SharedArrayや、init段階でのグローバル変数を使うことで、データを1回だけ読み込み、全VUで共有できます。

SharedArrayの実装例

import { SharedArray } from "k6/data";

// テスト設定データを全VUで共有
const testConfig = new SharedArray("config", () => {
  return JSON.parse(open("config.json"));
});

// バイナリデータ（例：テスト用のサンプルファイル）もinit段階で読み込む
const testDataFiles = {};

const files = ["sample1.bin", "sample2.bin", "sample3.bin"];
for (const file of files) {
  const data = open(file, "b") as ArrayBuffer;
  const length = data.byteLength;
  testDataFiles[file] = { data, length };
  console.log(`Loaded: ${file} (${length} bytes)`);
}

この方法により、200VUで実行しても、ファイルは1回だけメモリに読み込まれます。

WebSocket接続の実装

基本的な接続パターン

k6のws.connect()を使ってWebSocket接続を確立します。

WebSocket接続の実装例

import ws from "k6/ws";

const wsUrl = "wss://api.example.com/ws";

// 認証トークン（setup()で取得したものなど）
const authToken = data.token;
const sessionId = `session-${__VU}-${Date.now()}`;

const response = ws.connect(wsUrl, {}, (socket) => {
  // 接続成功時の処理
  socket.on("open", () => {
    console.log(`[VU ${__VU}] WebSocket connected`);

    // 認証メッセージの送信
    socket.send(JSON.stringify({
      type: "auth",
      token: authToken
    }));

    // 初期化メッセージの送信
    socket.send(JSON.stringify({
      command: "initialize",
      sessionId: sessionId
    }));
  });

  // メッセージ受信時の処理
  socket.on("message", (message) => {
    handleMessage(socket, message);
  });

  // エラーハンドリング
  socket.on("error", (e) => {
    console.error(`[VU ${__VU}] WebSocket error:`, e);
    wsConnectionErrors.add(1);
  });

  // 接続クローズ時の処理
  socket.on("close", () => {
    console.log(`[VU ${__VU}] WebSocket closed`);
  });

  // タイムアウト設定（60秒）
  socket.setTimeout(() => {
    console.log(`[VU ${__VU}] Test timeout: closing connection`);
    socket.close();
  }, 60000);
});

setup()での認証トークン取得

WebSocketの認証に必要なトークンは、setup()関数で事前に取得しておくと効率的です。

setup()関数の実装例

import http from "k6/http";

export function setup() {
  // 認証APIを呼び出してトークンを取得
  const loginRes = http.post("https://api.example.com/auth/login",
    JSON.stringify({
      username: __ENV.TEST_USERNAME,
      password: __ENV.TEST_PASSWORD,
    }),
    {
      headers: { "Content-Type": "application/json" }
    }
  );

  if (loginRes.status !== 200) {
    throw new Error(`Authentication failed: ${loginRes.status}`);
  }

  const token = JSON.parse(loginRes.body).token;

  return {
    token: token,
    timestamp: Date.now()
  };
}

export default function (data) {
  // data.tokenを使ってWebSocket接続
  const wsUrl = "wss://api.example.com/ws";

  ws.connect(wsUrl, {}, (socket) => {
    socket.on("open", () => {
      socket.send(JSON.stringify({
        type: "auth",
        token: data.token
      }));
    });
    // ...
  });
}

メッセージハンドリングのベストプラクティス

WebSocketのメッセージ処理では、メッセージタイプに応じた分岐処理が必要です。

メッセージハンドリングの実装例

const handleMessage = (socket, message, state) => {
  try {
    const data = JSON.parse(message);

    switch (data.type) {
      case "error":
        handleError(socket, data, state);
        break;
      case "ready":
        state.ready = true;
        handleReady(socket, data);
        break;
      case "response":
        handleResponse(data, state);
        break;
      case "status":
        handleStatus(data, state);
        break;
      default:
        console.log("Unknown message type:", data.type);
    }
  } catch (e) {
    console.error("Failed to parse message:", e);
  }
};

バイナリデータの送信

WebSocketでバイナリデータを送信する場合、sendBinary()メソッドを使用します。大きなファイルをチャンクに分割して送信することで、メモリ効率を高め、ネットワークの状態に応じて柔軟に制御できます。

バイナリチャンク送信の実装例

const sendBinaryChunks = (
  socket,
  state,
  binaryData,
  totalLength
) => {
  const CHUNK_SIZE = 2560; // チャンクサイズ（バイト）
  const CHUNK_INTERVAL_MS = 27; // 送信間隔（ミリ秒）

  const totalChunks = Math.ceil(totalLength / CHUNK_SIZE);
  console.log(`Sending ${totalChunks} chunks (${totalLength} bytes total)`);

  let offset = 0;
  let chunkIndex = 0;

  const sendNextChunk = () => {
    // 中断フラグチェック
    if (state.terminated) {
      console.log("Terminated; stop sending chunks.");
      return;
    }

    // 全チャンク送信完了
    if (offset >= totalLength) {
      console.log(`All chunks sent (${chunkIndex} total)`);
      scheduleFinish(socket, state);
      return;
    }

    // チャンクを切り出して送信
    const chunk = binaryData.slice(offset, offset + CHUNK_SIZE);
    socket.sendBinary(chunk);

    offset += CHUNK_SIZE;
    chunkIndex++;

    // 進捗ログ（10チャンクごと）
    if (chunkIndex % 10 === 0) {
      console.log(`Sent ${chunkIndex}/${totalChunks} chunks`);
    }

    // 次のチャンクをスケジュール
    if (!state.terminated) {
      socket.setTimeout(sendNextChunk, CHUNK_INTERVAL_MS);
    }
  };

  sendNextChunk();
};

タイミング制御のポイント

実際のアプリケーションの挙動を再現するため、適切なタイミング制御が重要です。

状態管理とタイミング制御の実装例

// 状態管理用オブジェクト
const state = {
  initialized: false,
  ready: false,
  bytesAcked: false,
  terminated: false,
  startTime: 0
};

socket.on("message", (message) => {
  const data = JSON.parse(message);

  // ステータスメッセージで初期化判定
  if (data.type === "status" && !state.initialized) {
    state.initialized = true;
    state.startTime = Date.now();

    // 設定送信
    socket.send(JSON.stringify({
      command: "configure",
      options: { /* ... */ }
    }));

    // バイナリデータ送信開始（50ms後）
    socket.setTimeout(() => {
      sendBinaryChunks(socket, state, binaryData, dataLength);
    }, 50);
  }

  // 受信確認で状態更新
  if (data.type === "ack" && data.receivedBytes >= dataLength) {
    state.bytesAcked = true;
  }
});

メトリクス収集とレイテンシ測定

k6のカスタムメトリクスを使って、詳細なパフォーマンス測定を実装します。

カスタムメトリクスの実装例

import { Counter, Rate, Trend } from "k6/metrics";

// メトリクス定義
const errorRate = new Rate("errors");
const wsConnectionErrors = new Rate("ws_connection_errors");
const wsAuthErrors = new Rate("ws_auth_errors");
const responseLatency = new Trend("response_latency");
const activeConnections = new Counter("active_connections");
const dataChunksSent = new Counter("data_chunks_sent");

// レイテンシ測定
const handleResponse = (data, state) => {
  if (!state.firstResponseReceived) {
    const latency = Date.now() - state.startTime;
    responseLatency.add(latency);
    state.firstResponseReceived = true;
    console.log(`First response received (latency: ${latency}ms)`);
  }
};

// エラー率の記録
const handleError = (socket, data, state) => {
  console.error("Error response:", JSON.stringify(data));

  if (data.error?.includes("Authorization")) {
    wsAuthErrors.add(1);
  }

  wsConnectionErrors.add(1);
  errorRate.add(1);
  state.terminated = true;
};

// アクティブ接続数の追跡
socket.on("open", () => {
  activeConnections.add(1);
});

socket.on("close", () => {
  activeConnections.add(-1);
});

// チャンク送信数のカウント
socket.sendBinary(chunk);
dataChunksSent.add(1);

閾値（Thresholds）の設定

メトリクスに閾値を設定して、パフォーマンス基準を明確化します。

閾値設定の例

export const options = {
  scenarios: {
    ramping_ws: {
      executor: "ramping-vus",
      gracefulRampDown: "5m",
      stages: [
        { duration: "2m", target: 10 },
        { duration: "5m", target: 50 },
        { duration: "5m", target: 100 },
        { duration: "3m", target: 0 },
      ],
    },
  },
  thresholds: {
    ws_connection_errors: ["rate<0.1"],      // 接続エラー率10%未満
    ws_auth_errors: ["rate<0.05"],           // 認証エラー率5%未満
    response_latency: ["p(95)<5000"],        // 95パーセンタイルが5秒未満
    errors: ["rate<0.1"],                    // 全体のエラー率10%未満
  },
};

負荷パターンの設計

k6では、stagesを使って段階的に負荷を増減させることができます。用途に応じて複数のパターンを用意し、環境変数で切り替えられるようにすると便利です。

負荷パターンの実装例

// 負荷パターンの定義
const LOAD_PATTERNS = {
  // スモークテスト: 最小限の負荷で動作確認
  smoke: [
    { duration: "30s", target: 1 },
    { duration: "30s", target: 1 },
  ],
  // 通常の負荷テスト
  load: [
    { duration: "2m", target: 10 },
    { duration: "5m", target: 50 },
    { duration: "5m", target: 50 },
    { duration: "2m", target: 0 },
  ],
  // ストレステスト: 高負荷での動作確認
  stress: [
    { duration: "2m", target: 50 },
    { duration: "5m", target: 100 },
    { duration: "5m", target: 200 },
    { duration: "2m", target: 0 },
  ],
};

// 環境変数で選択
const pattern = __ENV.LOAD_PATTERN || "load";
const stages = LOAD_PATTERNS[pattern];

export const options = {
  scenarios: {
    websocket_test: {
      executor: "ramping-vus",
      gracefulRampDown: "30s",
      stages: stages,
    },
  },
  thresholds: {
    ws_connection_errors: ["rate<0.1"],
    ws_auth_errors: ["rate<0.05"],
    response_latency: ["p(95)<5000"],
    errors: ["rate<0.1"],
  },
};

Docker化とCI/CD統合

Dockerfile

k6の実行環境をDocker化することで、ローカル環境やCI/CDで同じ環境でテストを実行できます。

Dockerfileの例

FROM grafana/k6:latest

WORKDIR /app

# テストスクリプトをコピー
COPY scripts/ /scripts/

# テスト設定ファイルをコピー
COPY config/ /config/

# バイナリデータサンプルをコピー（WebSocketで送信するテストデータ）
COPY test-data/ /test-data/

# 結果出力用のディレクトリを作成
RUN mkdir -p /results

# デフォルトのエントリーポイントはk6
ENTRYPOINT ["k6"]

ファイル構成例：

.
├── Dockerfile
├── scripts/
│   ├── websocket-test.ts      # メインテストスクリプト
│   ├── helpers/
│   │   ├── websocket.ts       # WebSocket関連のヘルパー関数
│   │   └── metrics.ts         # メトリクス収集
│   └── types/
│       └── index.ts           # 型定義
├── config/
│   └── config.json            # テスト設定
├── test-data/
│   ├── sample1.bin            # テスト用バイナリファイル
│   ├── sample2.bin
│   └── sample3.bin
└── results/                   # テスト結果の出力先（Docker実行時にマウント）

GitHub Actions統合

GitHub Actionsを使うことで、定期的な負荷テストや、デプロイ前の自動テストを実現できます。

GitHub Actionsワークフローの例

name: WebSocket Load Test

on:
  workflow_dispatch:
    inputs:
      load_pattern:
        description: 'Load pattern (smoke/load/stress)'
        required: true
        default: 'load'
        type: choice
        options:
          - smoke
          - load
          - stress

jobs:
  websocket-load-test:
    runs-on: ubuntu-latest
    timeout-minutes: 30

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Build k6 Docker image
        run: |
          docker build -f Dockerfile -t k6-websocket-test:latest .

      - name: Run WebSocket load test
        env:
          LOAD_PATTERN: ${{ github.event.inputs.load_pattern }}
          WS_URL: ${{ secrets.WS_URL }}
          API_BASE_URL: ${{ secrets.API_BASE_URL }}
          TEST_USERNAME: ${{ secrets.TEST_USERNAME }}
          TEST_PASSWORD: ${{ secrets.TEST_PASSWORD }}
        run: |
          docker run --rm \
            -e LOAD_PATTERN \
            -e WS_URL \
            -e API_BASE_URL \
            -e TEST_USERNAME \
            -e TEST_PASSWORD \
            -v $(pwd)/results:/results \
            k6-websocket-test:latest \
            run /scripts/websocket-test.ts \
            --out json=/results/k6-results.json

      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: k6-websocket-results-${{ github.event.inputs.load_pattern }}
          path: results/
          retention-days: 30

      - name: Check test thresholds
        if: always()
        run: |
          if [ -f results/k6-results.json ]; then
            echo "Load test completed. Check artifacts for detailed results."
          fi

ベストプラクティスとトラブルシューティング

メモリ使用量の最適化

大きなバイナリファイルを扱う場合、メモリ使用量に注意が必要です。

メモリ最適化のコード例

// ❌ 悪い例: 各VUでファイルを個別に読み込む
export default function () {
  const data = open("large-file.bin", "b"); // 各VUで10MBのメモリを消費
  // 100VUなら合計1GBのメモリを消費！
}

// ✅ 良い例: init段階でグローバル変数に保存
const testData = open("large-file.bin", "b");

export default function () {
  // 全VUでtestDataを共有（メモリは1回だけ確保）
  socket.sendBinary(testData.slice(offset, offset + CHUNK_SIZE));
}

WebSocketの適切なクローズ処理

エラー発生時も適切にWebSocket接続をクローズすることが重要です。

クローズ処理の実装例

// エラー時も必ずクローズする
const handleError = (socket, data, state) => {
  console.error("Error:", data);
  state.terminated = true;

  // 1.5秒後にクローズ（ログ出力の時間を確保）
  socket.setTimeout(() => {
    try {
      socket.close();
    } catch (e) {
      // クローズ済みでもエラーにしない
    }
  }, 1500);
};

ログ出力の工夫

複数のVUが同時に実行されるため、ログにVU番号を含めると追跡しやすくなります。

ログ出力の例

// VU番号を含めて、どのVUのログか識別可能にする
console.log(`[VU ${__VU}] WebSocket connected`);
console.log(`[VU ${__VU}] Sent ${chunkIndex}/${totalChunks} chunks`);
console.log(`[VU ${__VU}] First response received (latency: ${latency}ms)`);

タイムアウトとリトライの設計

適切なタイムアウト設定により、ハングアップを防ぎます。

タイムアウト設定の例

// WebSocket接続に全体タイムアウトを設定
socket.setTimeout(() => {
  console.log(`[VU ${__VU}] Test timeout: closing connection`);
  socket.close();
}, 60000); // 60秒

// チャンク送信の中断制御
const sendNextChunk = () => {
  // 状態フラグでいつでも中断可能にする
  if (state.terminated) {
    console.log("Terminated; stop sending chunks.");
    return;
  }

  // チャンク送信
  socket.sendBinary(chunk);

  // 次のチャンクをスケジュール
  socket.setTimeout(sendNextChunk, CHUNK_INTERVAL_MS);
};

まとめ

k6を使ったWebSocket負荷テストの実装では、以下のポイントが重要です：

WebSocketの状態管理: 接続、初期化、データ送信、クローズの各フェーズを適切に管理
バイナリデータのチャンク送信: sendBinary()で大きなファイルを分割送信し、タイミング制御
カスタムメトリクス: Rate、Trend、Counterを使った詳細なパフォーマンス測定
タイムアウトとエラーハンドリング: socket.setTimeout()と状態フラグで安全な制御
メモリ効率化: SharedArrayやinit段階のグローバル変数で大きなファイルを共有
CI/CD統合: Docker化と環境変数による柔軟なテスト実行

WebSocketは双方向通信のため、通常のHTTP負荷テストとは異なるアプローチが必要です。この記事で紹介したパターンを活用することで、リアルタイム通信サービスの性能問題を早期に発見し、安定したサービス運用を実現できます。

参考資料

Discussion