WebSocket è un protocollo che dal 2011 consente la comunicazione bidirezionale in tempo reale tra browser e server. A differenza dell'HTTP tradizionale, che funziona con il modello request‑response, WebSocket mantiene una connessione permanente, eliminando la necessità di aprire continuamente nuove connessioni. Grazie a ciò, applicazioni come chat, giochi online o dashboard che monitorano dati in tempo reale possono funzionare in modo fluido e con un overhead di rete minimo.
Come funziona WebSocket nel browser?
La connessione WebSocket inizia con una classica richiesta HTTP Upgrade. Il browser invia l'intestazione Upgrade: websocket e Sec-WebSocket-Key. Il server, se supporta il protocollo, risponde con il codice 101 Switching Protocols e restituisce Sec-WebSocket-Accept, che è il risultato di SHA‑1 e Base64 sulla chiave del client. Al termine di questo “handshake”, entrambe le parti passano alla modalità binaria, e tutti i frame successivi vengono trasmessi senza intestazioni HTTP.
Nel browser l'interfaccia WebSocket espone metodi semplici: new WebSocket(url), send() e gli eventi onmessage, onopen, onclose e onerror. In questo modo gli sviluppatori possono concentrarsi sulla logica dell'applicazione, senza preoccuparsi dei dettagli a basso livello del protocollo.
Vantaggi di WebSocket rispetto all'HTTP polling
- Una connessione permanente elimina il costo di apertura e chiusura di TCP/IP ad ogni richiesta.
- I frame hanno un’intestazione di pochi byte, riducendo significativamente l'overhead rispetto a un’intestazione HTTP completa ad ogni aggiornamento.
- Bidirezionalità – il server può iniziare un messaggio, cosa impossibile con HTTP puro senza tecniche come il long‑polling.
In pratica ciò si traduce in un consumo di banda inferiore, minori latenze e una migliore scalabilità con un gran numero di client simultanei.
Implementazione di WebSocket in Node.js
Nell'ecosistema Node.js la libreria più popolare è ws. La installiamo con il comando npm install ws, quindi creiamo il server:
const http = require('http');
const WebSocket = require('ws');
const server = http.createServer();
const wss = new WebSocket.Server({ server });
wss.on('connection', ws => {
console.log('Nowe połączenie');
ws.on('message', msg => {
console.log('Otrzymano:', msg);
// Echo do wszystkich klientów
wss.clients.forEach(client => {
if (client.readyState === WebSocket.OPEN) {
client.send(`Echo: ${msg}`);
}
});
});
});
server.listen(8080, () => console.log('Serwer nasłuchuje na 8080'));
Nel esempio sopra, il server HTTP e WebSocket condividono la stessa porta, semplificando la configurazione negli ambienti cloud. È consigliabile aggiungere la gestione di ping/pong per rilevare i client disconnessi e limitare la dimensione massima dei messaggi, migliorando la stabilità.
WebSocket e scalabilità in Docker e Kubernetes
La containerizzazione non modifica il protocollo, ma introduce sfide legate alla distribuzione delle connessioni. Poiché WebSocket mantiene una connessione permanente, i tradizionali load balancer round‑robin possono distribuire il traffico in modo casuale, portando a situazioni in cui la connessione del client venga indirizzata a un pod diverso dopo una breve interruzione. Per questo, in Kubernetes si raccomanda l'uso della session affinity o di un proxy di livello, come nginx in modalità stream, che mantiene le “sticky sessions”.
Esempio di configurazione nginx:
stream {
upstream ws_backend {
server ws-app-1:8080;
server ws-app-2:8080;
sticky;
}
server {
listen 443 ssl;
proxy_pass ws_backend;
proxy_ssl_certificate /etc/ssl/cert.pem;
proxy_ssl_certificate_key /etc/ssl/key.pem;
}
}
Inoltre, per abilitare la scalabilità orizzontale, è utile separare la logica di distribuzione dei messaggi dal server WebSocket stesso. Una soluzione comune è l'uso di sistemi di code (ad es. Redis Pub/Sub, NATS) – ogni pod pubblica eventi e tutti li sottoscrivono per inoltrarli ai client connessi.
Sicurezza delle connessioni WebSocket
La base è l'uso del protocollo wss://, ovvero WebSocket over TLS. Un certificato TLS cripta l'intero canale, come avviene con HTTPS. Inoltre, è consigliabile introdurre l'autorizzazione durante l'handshake – tipicamente tramite token JWT inviato nell'intestazione Sec-WebSocket-Protocol o come parametro della query. Il server verifica il token e rifiuta le connessioni non autorizzate.
Dopo l'instaurazione della connessione, si raccomanda di limitare i privilegi a livello applicativo: ad esempio assegnare stanze (rooms) solo a utenti specifici. È inoltre utile monitorare i limiti di messaggi (rate limiting) e implementare meccanismi di protezione contro attacchi DoS, che potrebbero sovraccaricare il server con centinaia di migliaia di connessioni aperte.
«Un WebSocket stabile e sicuro non è solo un protocollo – è un insieme di pratiche che devono accompagnare ogni implementazione in produzione.»
Checklist pratica per l'implementazione di WebSocket
- Usa
wss://e installa un certificato TLS. - Richiedi l'autorizzazione durante l'handshake (JWT, OAuth).
- Configura sticky sessions nel load balancer o proxy.
- Implementa un meccanismo ping/pong e timeout.
- Separa la logica di distribuzione dei messaggi (ad es. Redis Pub/Sub).
- Limita la dimensione e la frequenza dei messaggi (rate limiting).
Errori comuni e compromessi
Uno degli errori più frequenti è ignorare lo strato proxy durante il deployment su Kubernetes, il che porta alla perdita delle connessioni dopo poco tempo. Un altro problema è la mancanza di crittografia – le connessioni WebSocket senza TLS sono vulnerabili agli attacchi man‑in‑the‑middle. Spesso gli sviluppatori presumono anche che WebSocket risolva tutti i problemi di performance; in realtà, con un numero molto elevato di connessioni simultanee è necessario un meccanismo di coda aggiuntivo e scalabilità orizzontale.
I compromessi emergono nella scelta della dimensione dei messaggi. Frame troppo piccoli aumentano il numero di operazioni I/O, mentre quelli troppo grandi possono causare frammentazione e un maggiore consumo di memoria. L'approccio ottimale è profilare l'applicazione per la dimensione tipica del payload e adeguare i limiti di conseguenza.
In sintesi, il protocollo WebSocket è uno strumento potente per le applicazioni real‑time, ma richiede un approccio consapevole alla scalabilità e alla sicurezza. Se hai bisogno di assistenza nella progettazione di un'architettura basata su WebSocket, integrazione con Kubernetes o audit di sicurezza, contatta Coderia.it – insieme costruiremo soluzioni solide ed efficienti.
