0Pricing
WebSockets & Realtime Systems Programming · Aula

Sinais de atividade e manutenção da conexão

Aprenda a usar quadros de ping/pong e sinais de atividade no nível da aplicação para manter a conexão ativa e detectar pares inativos.

Sinais de atividade e manutenção da conexão é uma aula grátis de WebSockets & Realtime Systems Programming no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de WebSockets & Realtime Systems Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de WebSockets & Realtime Systems Programming inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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.

Perguntas Frequentes

A aula “Sinais de atividade e manutenção da conexão” é grátis?

Sim — o texto completo de “Sinais de atividade e manutenção da conexão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de WebSockets & Realtime Systems Programming, atualize para CoddyKit PRO. O curso de WebSockets & Realtime Systems Programming inclui 4 aulas no total.

O que vou aprender em “Sinais de atividade e manutenção da conexão”?

Aprenda a usar quadros de ping/pong e sinais de atividade no nível da aplicação para manter a conexão ativa e detectar pares inativos. Você pratica WebSockets & Realtime Systems Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar WebSockets & Realtime Systems Programming?

Nenhuma experiência prévia é necessária. WebSockets & Realtime Systems Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Sinais de atividade e manutenção da conexão”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de WebSockets & Realtime Systems Programming?

Sim. Cada aula de WebSockets & Realtime Systems Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Como lidar com desconexões e reconexões
  2. Propagação e recuperação robustas de erros
  3. Sinais de atividade e manutenção da conexão
  4. Confirmação de mensagens e garantias de entrega
← Voltar para WebSockets & Realtime Systems Programming