Load Testing & Performance Benchmarking (JMeter & k6) · 课时

WebSocket 与流式传输测试

探索使用 WebSockets 和流式协议对实时应用进行性能测试的方法

WebSocket 与流式传输测试 是 CoddyKit 上的免费 Load Testing & Performance Benchmarking (JMeter & k6) 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Load Testing & Performance Benchmarking (JMeter & k6) 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Load Testing & Performance Benchmarking (JMeter & k6) 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Real-Time Apps Need Special Tests

Chat applications, live dashboards, and online games are examples of real-time applications. They demand constant, fast updates and immediate interaction.

Traditional HTTP testing, which relies on a request-response model, doesn't fully capture the behavior of these dynamic systems. We need specific tools and methods to test them effectively.

Understanding WebSockets

WebSockets provide a persistent, bi-directional communication channel over a single TCP connection. This means both the client and server can send data to each other at any time.

Unlike HTTP, which opens and closes connections for each request, WebSockets establish an initial 'handshake' and then maintain an open connection for continuous, 'full-duplex' communication. This makes them ideal for real-time interactions.

Unique Challenges of WebSocket Testing

Performance testing WebSockets presents distinct challenges compared to traditional HTTP:

Persistent Connections: Simulating many open, long-lived connections for extended durations.
Bi-directional Flow: Handling messages sent by both client and server asynchronously.
Dynamic Content: Validating constantly updating data streams rather than static responses.

Our testing tools must be capable of managing these continuous interactions.

JMeter for WebSocket Load Testing

JMeter can be extended to test WebSockets using third-party plugins (e.g., the WebSocket Samplers by Maciej Zaleski).

These plugins allow you to:

Open and close WebSocket connections.
Send messages to the server.
Listen for and capture incoming messages.

You'll configure these steps within JMeter's graphical user interface (GUI).

Configuring a JMeter WebSocket Test

To establish a WebSocket connection in JMeter, you typically add a 'WebSocket Open Connection' sampler. Here, you specify the WebSocket URL (ws:// or wss://).

Subsequent 'WebSocket Request' samplers can then be used to send messages. To end the connection, a 'WebSocket Close' sampler is used. You can also add 'Response Assertions' to validate received messages.

k6: Scripting WebSocket Tests with JavaScript

k6 offers native support for WebSockets through its ws module, making it a powerful and flexible choice for real-time testing.

You write your test logic in JavaScript, defining how virtual users interact with the WebSocket server. This provides great flexibility for creating complex, stateful scenarios that accurately simulate user behavior.

Basic k6 WebSocket Connection

Let's see how to establish a simple WebSocket connection with k6. This script connects to a public test WebSocket echo server and then immediately closes the connection.

import ws from 'k6/ws';
import { check } from 'k6';

export default function () {
  const url = 'ws://echo.websocket.events/'; // A public echo server
  const params = { tags: { ws_tag: 'hello' } };

  const res = ws.connect(url, params, function (socket) {
    socket.on('open', () => console.log('Connected!'));
    socket.on('close', () => console.log('Disconnected!'));
    socket.on('error', (e) => console.log('Error:', e.error()));

    socket.close(); // Close immediately after connecting
  });

  check(res, { 'status is 101': (r) => r && r.status === 101 });
}

Sending and Receiving Messages in k6

Now, let's extend our k6 script to send a message and wait for a response from the echo server. We use socket.send() to transmit data and handle incoming messages with socket.on('message').

import ws from 'k6/ws';
import { check } from 'k6';

export default function () {
  const url = 'ws://echo.websocket.events/';

  ws.connect(url, null, function (socket) {
    socket.on('open', () => {
      console.log('Connected, sending message...');
      socket.send('Hello CoddyKit!');
    });

    socket.on('message', (data) => {
      console.log('Received:', data);
      check(data, { 'message is "Hello CoddyKit!"': (d) => d === 'Hello CoddyKit!' });
      socket.close(); // Close after receiving the message
    });

    socket.on('close', () => console.log('Disconnected!'));
    socket.on('error', (e) => console.log('Error:', e.error()));

    // Keep the VU alive until a message is received or timeout
    socket.prune();
  });
}

Ensuring Correctness with k6 Checks

Just like with HTTP requests, you need to validate the content of WebSocket messages to ensure the real-time data flow is correct under load.

k6's check() function is perfect for this. You can assert on the message content, format, or specific fields received from the server.

import ws from 'k6/ws';
import { check } from 'k6';

export default function () {
  const url = 'ws://echo.websocket.events/';
  const expectedMessage = 'Test Message 123';

  ws.connect(url, null, function (socket) {
    socket.on('open', () => {
      socket.send(expectedMessage);
    });

    socket.on('message', (data) => {
      console.log('Received:', data);
      check(data, {
        'received message matches sent': (d) => d === expectedMessage,
        'message length is correct': (d) => d.length === expectedMessage.length,
      });
      socket.close();
    });

    socket.on('close', () => console.log('Disconnected!'));
    socket.on('error', (e) => console.log('Error:', e.error()));

    socket.prune();
  });
}

Testing Other Streaming Protocols

While WebSockets are popular, other streaming protocols exist:

Server-Sent Events (SSE): A uni-directional protocol where the server pushes updates to the client. Easier for simple data feeds.
gRPC Streaming: Uses HTTP/2 for efficient bi-directional streaming, often favored in microservices architectures. Requires specialized gRPC testing tools.

Each protocol has its own testing considerations and may require dedicated tools or libraries.

Quick Check

Consider a real-time chat application where users constantly send and receive messages. Which statement best describes why WebSockets are generally preferred over traditional HTTP for this scenario?

Recap: Mastering Real-Time Tests

We've explored the unique challenges of testing real-time applications using WebSockets and streaming protocols.

You learned that:

WebSockets offer persistent, bi-directional communication.
JMeter (with plugins) and k6 (native support) are key tools for testing them.
k6 provides flexible JavaScript scripting for complex scenarios.
Validation of dynamic messages using checks is crucial.

Understanding these concepts is vital for ensuring the performance of modern, interactive applications.

常见问题解答

「WebSocket 与流式传输测试」课时是免费的吗？

是的 — 「WebSocket 与流式传输测试」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Load Testing & Performance Benchmarking (JMeter & k6) 课程的其余内容，请升级到 CoddyKit PRO。 Load Testing & Performance Benchmarking (JMeter & k6) 课程共包含 4 节课。

「WebSocket 与流式传输测试」这节课中我会学到什么？

探索使用 WebSockets 和流式协议对实时应用进行性能测试的方法你通过在浏览器中直接运行的动手代码来练习 Load Testing & Performance Benchmarking (JMeter & k6)，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Load Testing & Performance Benchmarking (JMeter & k6) 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Load Testing & Performance Benchmarking (JMeter & k6) 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「WebSocket 与流式传输测试」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Load Testing & Performance Benchmarking (JMeter & k6) 课中编写并运行代码吗？

能。每节 Load Testing & Performance Benchmarking (JMeter & k6) 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Load Testing & Performance Benchmarking (JMeter & k6)