WebSocket: cos'è, protocollo di comunicazione full-duplex e come funziona

Cos'è WebSocket?

WebSocket è un protocollo di comunicazione che opera su TCP e fornisce un canale full-duplex tra un client e un server. È stato standardizzato dall'IETF come RFC 6455 nel 2011 ed è supportato da tutti i browser moderni, piattaforme mobili e framework server.

A differenza di HTTP, dove il client avvia una richiesta e riceve una risposta, WebSocket consente a entrambe le parti di inviare messaggi in qualsiasi momento dopo l'instaurazione della connessione. Questo lo rende ideale per scenari che richiedono consegna istantanea dei dati: chat, notifiche, modifica collaborativa di documenti.

Il protocollo WebSocket utilizza la porta HTTP 80 o la porta HTTPS 443 per l'handshake iniziale, dopodiché passa al proprio protocollo con un'intestazione minima — solo 2 byte invece di 800+ byte in HTTP. Questa caratteristica offre un vantaggio significativo in termini di prestazioni con un gran numero di messaggi.

Caratteristiche principali del protocollo

Una connessione WebSocket inizia con una richiesta HTTP di aggiornamento (Upgrade), dopodiché il protocollo passa a un formato di frame binario. La dimensione del frame varia da 2 byte a 2^63 byte, consentendo la trasmissione sia di brevi messaggi di testo che di grandi dati binari. Il protocollo supporta la frammentazione dei messaggi, il mascheramento dei dati dal client al server e il ping/pong per mantenere attiva la connessione.

Come funziona WebSocket?

Il processo di instaurazione di una connessione WebSocket consiste in due fasi: handshake e trasferimento dati. Durante l'handshake, il client invia una richiesta HTTP con l'intestazione Upgrade: websocket, e il server conferma il cambio di protocollo con lo stato 101 Switching Protocols. Dopodiché, la connessione entra in modalità di trasmissione full-duplex.

Ogni messaggio in WebSocket è diviso in frame. Un frame contiene un opcode (testo, dati binari, chiusura, ping/pong), la lunghezza del payload e una chiave di mascheramento per i dati dal client. I frame possono essere frammentati — i frame di controllo (ping/pong) possono essere trasmessi tra i frammenti di messaggio, prevenendo il timeout della connessione durante trasferimenti lunghi.

const ws = new WebSocket('wss://example.com/chat')

ws.addEventListener('open', () => {
    console.log('Connessione stabilita')
    ws.send('Ciao, server!')
})

ws.addEventListener('message', (event) => {
    console.log('Ricevuto:', event.data)
})

ws.addEventListener('close', () => {
    console.log('Connessione chiusa')
})

Nell'esempio sopra, il client crea un oggetto WebSocket specificando l'URL sicuro wss://. Dopo l'apertura della connessione, viene inviato un messaggio di benvenuto e il gestore dei messaggi riceve le risposte dal server. Alla chiusura, si attiva il gestore di chiusura — questo è importante per la riconnessione in caso di interruzioni di rete.

WebSocket vs HTTP: confronto

La principale differenza tra WebSocket e HTTP risiede nel modello di interazione. HTTP opera secondo uno schema di richiesta-risposta: il client avvia una richiesta, il server restituisce una risposta e la connessione viene chiusa. WebSocket, invece, stabilisce un canale persistente attraverso il quale entrambe le parti possono avviare la trasmissione in qualsiasi momento.

Per le applicazioni che richiedono bassa latenza e un flusso costante di dati, WebSocket è significativamente più efficiente. HTTP Long Polling — un'alternativa in cui il server mantiene la richiesta aperta fino a quando i dati non sono disponibili — crea un carico eccessivo sul server e aumenta il consumo di memoria a causa di molteplici connessioni simultanee.

Secondo High Performance Browser Networking (Grigorik, O'Reilly), WebSocket riduce la latenza di rete negli scenari in tempo reale del 40-60% rispetto a HTTP Long Polling, mentre il carico del server si riduce di 3-5 volte grazie all'eliminazione degli handshake ripetuti.

Dove si usa WebSocket?

Grazie alla sua bassa latenza e comunicazione bidirezionale, WebSocket è utilizzato in un'ampia gamma di applicazioni. Gli scenari principali includono messaggistica istantanea, sincronizzazione dello stato nei giochi e trasmissione di dati di mercato nei sistemi finanziari.

Chat e messaggistica

WebSocket è diventato lo standard de facto per le applicazioni di chat. Piattaforme come Slack, Telegram Web e WhatsApp Web utilizzano WebSocket per la consegna istantanea dei messaggi. Il protocollo consente di inviare sia messaggi di testo che file attraverso un singolo canale, mentre il meccanismo ping/pong mantiene la connessione attiva anche durante i periodi di inattività.

Giochi online

I giochi multiplayer per browser e dispositivi mobili richiedono una latenza minima per sincronizzare lo stato dei giocatori. WebSocket trasmette coordinate, azioni ed eventi in tempo reale senza i ritardi delle richieste HTTP. Framework come Socket.IO e Colyseus astraggono le operazioni di basso livello del protocollo, aggiungendo riconnessione automatica e stanze.

Applicazioni finanziarie

I terminali di trading e le piattaforme di negoziazione utilizzano WebSocket per ricevere quotazioni in tempo reale. Un ritardo di pochi millisecondi può costare milioni di dollari, quindi le API finanziarie — come Binance WebSocket Streams, Coinbase Pro — forniscono interfacce WebSocket per i dati di mercato.

Applicazioni mobili e IoT

Nello sviluppo mobile, WebSocket viene utilizzato tramite API native: URLSessionWebSocketTask su iOS e OkHttp WebSocket su Android. Per Flutter, esiste la libreria web_socket_channel, e per React Native — react-native-websocket. I dispositivi IoT utilizzano WebSocket per trasmettere telemetria e ricevere comandi di controllo, poiché il protocollo consuma meno energia rispetto all'HTTP polling costante.

Esempi di codice WebSocket

Consideriamo un esempio lato server usando Node.js con la libreria ws — l'implementazione WebSocket più popolare per JavaScript. Il server accetta connessioni, elabora i messaggi e li trasmette a tutti i client connessi.

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

wss.on('connection', (ws) => {
    console.log('Nuovo client connesso')

    ws.on('message', (data) => {
        console.log('Ricevuto:', data.toString())
        ws.send('Il server ha ricevuto il tuo messaggio')
    })

    ws.on('close', () => {
        console.log('Client disconnesso')
    })
})

console.log('Server WebSocket avviato sulla porta 8080')

Il server crea un'istanza di WebSocket.Server sulla porta 8080 e attende le connessioni. A ogni nuovo client viene assegnato un oggetto ws separato attraverso il quale il server può inviare messaggi individuali. La trasmissione dei messaggi a tutti i client è implementata iterando attraverso l'array delle connessioni. Con un gran numero di client (oltre 1000), si consiglia di utilizzare librerie con supporto al clustering, come Socket.IO, che aggiungono scalabilità basata su Redis e riconnessione automatica.

Inviare messaggi a tutti i client

wss.clients.forEach((client) => {
    if (client.readyState === WebSocket.OPEN) {
        client.send('Messaggio per tutti i partecipanti')
    }
})

Verificare il readyState prima dell'invio è obbligatorio: se il client si è già disconnesso, chiamare send genererà un errore. Il flag WebSocket.OPEN garantisce che la connessione sia attiva e che il messaggio venga consegnato.

Per le applicazioni mobili iOS, WebSocket è implementato tramite URLSessionWebSocketTask, disponibile da iOS 13. La sessione crea un'attività con un URL di protocollo wss://, dopodiché vengono chiamati i metodi send e receive. La ricezione dei messaggi può essere organizzata attraverso una ricorsione continua di receive, che attende il messaggio successivo dopo aver elaborato il precedente, garantendo una ricezione costante dei dati senza riconnessione. Per Android, viene utilizzato OkHttp WebSocket, che fornisce un'interfaccia simile con callback onOpen, onMessage, onClosing e onClosed, oltre alla riconnessione automatica in caso di perdita di connessione.

Quando si lavora con WebSocket in applicazioni mobili, è importante considerare la gestione del ciclo di vita: quando l'app va in background, il sistema potrebbe terminare la connessione. Su iOS, la connessione deve essere ristabilita al ritorno in primo piano tramite il delegato sceneDidBecomeActive. Su Android, è necessario utilizzare componenti Lifecycle-aware o un Service per mantenere la connessione. Inoltre, si consiglia di implementare un backoff esponenziale per la riconnessione — aumentare l'intervallo tra i tentativi da 1 a 30 secondi — per evitare di creare un carico eccessivo sul server durante problemi di rete temporanei.