0Pricing
WebSockets & Realtime Systems Programming · Урок

Сигналы активности и поддержание соединения

Научитесь использовать кадры ping/pong и сигналы активности на уровне приложения, чтобы поддерживать соединение активным и обнаруживать недоступные узлы.

«Сигналы активности и поддержание соединения» — бесплатный урок WebSockets & Realtime Systems Programming на CoddyKit. Это урок 3 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения WebSockets & Realtime Systems Programming, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс WebSockets & Realtime Systems Programming содержит 4 уроков всего.

Части этого урока еще не переведены и отображаются на английском.

Why Heartbeats Matter

In realtime applications, maintaining an active and healthy connection is crucial. But what happens if a connection silently drops?

  • Heartbeats are small, periodic messages exchanged between connected parties.
  • They act as a 'pulse check' to confirm that both the client and server are still alive and responsive.
  • This helps detect 'dead' connections that haven't properly closed, preventing resources from being tied up indefinitely.

The Silent Dead Peer

Imagine a client suddenly losing network connectivity (e.g., Wi-Fi drops, device sleeps) without gracefully closing its WebSocket connection.

  • The server might still think the client is connected.
  • Messages sent to this 'dead' client will never arrive.
  • This wastes server resources and leads to inconsistent application states.
  • Heartbeats provide a way to proactively identify and terminate these unresponsive connections.

Native WebSocket Pings

The WebSocket protocol includes built-in mechanisms for heartbeats: Ping and Pong frames.

  • A server (or client) can send a special Ping frame to its peer.
  • Upon receiving a Ping, the peer is expected to automatically respond with a Pong frame.
  • These frames are lightweight control messages, not application data.
  • They confirm the underlying TCP connection is still active and can transmit data.

Server Sends Ping (Node.js)

Here's how a Node.js WebSocket server can send periodic ping frames to its connected clients. The ws library handles the low-level details.

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', ws => {
  console.log('Client connected');

  // Send a ping every 5 seconds
  const pingInterval = setInterval(() => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.ping();
      console.log('Server sent ping.');
    }
  }, 5000);

  ws.on('pong', () => {
    console.log('Client responded with pong!');
  });

  ws.on('close', () => {
    console.log('Client disconnected');
    clearInterval(pingInterval);
  });

  ws.on('error', error => {
    console.error('WS error:', error);
    clearInterval(pingInterval);
  });
});

console.log('Server running on ws://localhost:8080');

Client Pongs Automatically

When a WebSocket client (like a browser or Node.js client using ws) receives a native Ping frame:

  • It automatically sends back a Pong frame without any explicit code from you.
  • This makes native pings very efficient for basic connection liveness checks.
  • If a Ping is sent and no Pong is received within a timeout, the server can infer the connection is dead and close it.

Beyond Native Pings

While native Ping/Pong frames are great for TCP connection liveness, they have limitations:

  • They don't check if the application layer is still responsive.
  • Proxies or load balancers might sometimes interfere with or not forward these control frames correctly.
  • They don't provide a way to carry custom data, like a timestamp or a user ID.

This is where application-level heartbeats come in.

App Heartbeat Scenarios

Application-level heartbeats are custom messages sent over the WebSocket connection, designed to be handled by your application logic. They are useful for:

  • Detecting liveness through WebSocket-unaware proxies.
  • Ensuring the application itself (not just the TCP connection) is responsive.
  • Implementing more sophisticated timeouts based on user activity, not just network activity.
  • Allowing custom data payloads (e.g., client status, last active time).

Client App Heartbeat (Node.js)

A client can send custom 'heartbeat' messages at regular intervals. This example uses a Node.js client, but browser clients would follow a similar pattern.

const WebSocket = require('ws');
const ws = new WebSocket('ws://localhost:8080');
let appHeartbeatInterval;

ws.onopen = () => {
  console.log('Connected to server.');
  // Send a custom heartbeat every 3 seconds
  appHeartbeatInterval = setInterval(() => {
    const message = JSON.stringify({
      type: 'APP_HEARTBEAT',
      timestamp: Date.now()
    });
    ws.send(message);
    console.log('Client sent APP_HEARTBEAT.');
  }, 3000);
};

ws.onmessage = event => {
  console.log('Received:', event.data);
};

ws.onclose = () => {
  console.log('Disconnected.');
  clearInterval(appHeartbeatInterval);
};

ws.onerror = error => {
  console.error('WS error:', error);
  clearInterval(appHeartbeatInterval);
};

Server Tracks App Heartbeats

The server receives these custom messages and updates a 'last seen' timestamp for each client. If a client's timestamp isn't updated for too long, the server can close the connection.

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', ws => {
  console.log('Client connected');
  ws.lastAppHeartbeat = Date.now(); // Initialize timestamp

  const checkInterval = setInterval(() => {
    // If no app heartbeat in 6 seconds, assume dead
    if (Date.now() - ws.lastAppHeartbeat > 6000) {
      console.log('Client unresponsive (app heartbeat). Terminating.');
      ws.terminate(); // Force close the connection
      clearInterval(checkInterval);
    }
  }, 2000); // Check every 2 seconds

  ws.on('message', message => {
    const parsed = JSON.parse(message);
    if (parsed.type === 'APP_HEARTBEAT') {
      ws.lastAppHeartbeat = Date.now(); // Update timestamp
      // console.log('Received custom APP_HEARTBEAT from client');
    }
    // Handle other messages...
  });

  ws.on('close', () => {
    console.log('Client disconnected');
    clearInterval(checkInterval);
  });

  ws.on('error', error => {
    console.error('WS error:', error);
    clearInterval(checkInterval);
  });
});
console.log('Server running on ws://localhost:8080');

Check Your Understanding

Select all statements that accurately describe WebSocket heartbeats and keep-alives:

Lesson Summary

We've explored the critical role of heartbeats in maintaining robust WebSocket connections:

  • Native Ping/Pong frames check TCP connection liveness, with clients responding automatically.
  • Application-level heartbeats provide a more robust and customizable way to ensure the application itself is responsive, especially useful with proxies.
  • Both methods prevent 'dead' connections from consuming resources and improve overall system resilience.

Mastering heartbeats is essential for building stable and scalable realtime applications.

Часто задаваемые вопросы

Урок «Сигналы активности и поддержание соединения» бесплатный?

Да — полный текст урока «Сигналы активности и поддержание соединения» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс WebSockets & Realtime Systems Programming, подпишись на CoddyKit PRO. Курс WebSockets & Realtime Systems Programming содержит 4 уроков всего.

Чему я научусь в уроке «Сигналы активности и поддержание соединения»?

Научитесь использовать кадры ping/pong и сигналы активности на уровне приложения, чтобы поддерживать соединение активным и обнаруживать недоступные узлы. Ты практикуешь WebSockets & Realtime Systems Programming с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать WebSockets & Realtime Systems Programming?

Предыдущий опыт не требуется. WebSockets & Realtime Systems Programming на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 3 из 4.

Сколько времени занимает урок «Сигналы активности и поддержание соединения»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке WebSockets & Realtime Systems Programming?

Да. Каждый урок WebSockets & Realtime Systems Programming включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Обработка отключений и повторных подключений
  2. Надёжная передача и восстановление после ошибок
  3. Сигналы активности и поддержание соединения
  4. Подтверждение сообщений и гарантии доставки
← Назад к WebSockets & Realtime Systems Programming