← Blog
10 min di lettura
|
Pubblicato
|
Aggiornato

Webhooks vs WebSockets: quando usare l'uno o l'altro

Webhooks vs WebSockets a confronto per connessione, ritentativi, scalabilità e sicurezza, con una checklist decisionale e il pattern webhook-coda-WebSocket.

Capitoli
C
Chaingateway Team
Esperti di blockchain

Verificato da Maurice Sobiera

Illustrazione isometrica di un'architettura webhook a ventaglio

Un webhook è una richiesta HTTP unidirezionale che un server invia al vostro URL quando si verifica un evento. Un WebSocket è una connessione persistente e bidirezionale per la comunicazione continua. I webhook servono per gli eventi tra server, come le conferme di pagamento, mentre i WebSocket servono per gli aggiornamenti in tempo reale nel browser. Molti sistemi combinano entrambi.


In breve:

  • I webhook sono ideali per le notifiche tra server provenienti da servizi di terze parti, ma richiedono un URL pubblico e raggiungibile, firme sicure e risposte rapide.
  • I WebSocket sono più adatti alla comunicazione bidirezionale in tempo reale con browser o app, ma richiedono una gestione della connessione e dello stato, inclusa la logica di riconnessione.
  • Combinare webhook e WebSocket offre un’architettura resiliente: i webhook gestiscono l’ingestione degli eventi, mentre i WebSocket portano gli aggiornamenti ai client in modo efficiente.
  • Scalare i WebSocket significa gestire molte connessioni aperte con sticky session o un message broker condiviso, mentre i webhook scalano facilmente con un’elaborazione serverless senza stato e con code.
  • La sicurezza dei webhook si basa su firme con rotazione e su TLS; quella dei WebSocket punta sull’autenticazione della connessione e sulla validazione di ogni messaggio per impedire accessi non autorizzati.

Indice

Che cos’è un webhook e come funziona?

Un webhook inizia con una registrazione. Si fornisce a un provider (un processore di pagamenti, un host Git, un nodo blockchain) un URL. Quando si attiva un evento rilevante, il provider invia una richiesta HTTP POST con un payload JSON a quell’URL. Niente polling, niente connessione aperta che resta inattiva. È un push guidato dagli eventi su HTTP standard, e per questo si integra facilmente nell’architettura che si gestisce già.

Il punto critico sono le garanzie di consegna. Molti provider di webhook usano una semantica di consegna almeno una volta: se l’endpoint non restituisce una risposta 2xx abbastanza in fretta, il provider riprova, e alcuni riprovano per ore o giorni. Il gestore deve quindi essere idempotente, cioè poter elaborare due volte la stessa consegna senza creare addebiti o righe di database duplicati. Il Webhook Security Cheat Sheet di OWASP raccomanda per questo gestori idempotenti basati sull’ID dell’evento. Non tutti i provider ritentano. Chaingateway non ritenta automaticamente i webhook falliti, ma elenca le notifiche non riuscite e le invia di nuovo su richiesta.

Poiché i webhook richiedono un URL raggiungibile, comportano anche una propria checklist operativa:

  • Un endpoint pubblico che resiste alla configurazione di firewall e load balancer
  • La verifica della firma (di solito HMAC) per confermare che la richiesta provenga davvero dal provider
  • La registrazione degli ID delle consegne, per tracciare duplicati o mancanze
  • Un tempo di risposta abbastanza rapido da evitare ritentativi per una richiesta ancora in elaborazione

I webhook si trovano dietro le conferme di pagamento, i trigger delle pipeline CI/CD, le notifiche di push Git e gli avvisi di deposito. Sono inoltre una scelta naturale per i backend serverless, perché non c’è uno stato di connessione da mantenere attivo tra un’invocazione e l’altra.

Come funziona una connessione WebSocket?

Una connessione WebSocket inizia come una normale richiesta HTTP e poi passa a un altro protocollo. Il client invia l’header Upgrade: websocket, il server accetta, e da quel momento entrambi i lati possono inviare messaggi sulla stessa connessione TCP, come specifica la RFC 6455. È quindi full-duplex: server e client possono inviare dati in qualsiasi momento, non solo in risposta a una richiesta.

La parte difficile non è l’handshake, ma tutto ciò che viene dopo. Le connessioni cadono, le reti hanno problemi, le schede dei browser vanno in sospensione. Il codice client ha bisogno di una logica di riconnessione, e bisogna controllare bufferedAmount per evitare di accodare messaggi in uscita più velocemente di quanto il socket riesca a inviarli. MDN documenta l’intero ciclo di vita nella sua guida alle WebSockets API.

Lato server, i WebSocket sono stateful. Ogni connessione aperta occupa un file descriptor e un po’ di memoria. Con più istanze del server servono sticky session oppure un message broker (Redis pub/sub, NATS), così che un messaggio pubblicato su un’istanza raggiunga un client connesso a un’altra.

Gli usi più comuni includono:

  • Applicazioni di chat ed editor collaborativi
  • Dashboard in tempo reale e ticker di borsa
  • Sincronizzazione dello stato dei giochi multiplayer
  • Indicatori di presenza (“l’utente sta scrivendo”)

Se servono una gestione più avanzata della contropressione o API basate su stream, si possono valutare WebTransport e WebSocketStream. Entrambi affrontano i punti deboli della API WebSocket classica, e il supporto dei browser varia, quindi conviene controllare le tabelle di compatibilità di MDN prima di affidarsi a uno dei due.

Come si confrontano tecnicamente webhook e WebSocket?

ProprietàWebhookWebSocket
Persistenza della connessioneNessuna, una richiesta per eventoPersistente, resta aperta
Direzione / chi avviaUnidirezionale; il provider avvia ogni pushBidirezionale; dopo l’handshake invia ciascun lato
Protocollo / porteHTTP/HTTPS, porte standardws/wss, con upgrade da HTTP, porte standard
StatoSenza stato tra una chiamata e l’altraCon stato per tutta la durata della connessione
Garanzie di consegna / ritentativiAlmeno una volta, il provider riprova in caso di erroreNessun ritentativo integrato; l’app deve gestire le disconnessioni
Chi gestisce i ritentativiIl provider mittente (con il vostro gestore idempotente)Il codice client e server
Latenza tipica / ideali perQuasi in tempo reale, adatti alle notifiche di eventiLatenza minima, ideali per l’interattività continua
Modello di sicurezzaFirme HMAC, TLS, controlli del timestampHandshake TLS (wss), token di autenticazione per connessione
Requisito di endpoint pubblicoObbligatorio, deve essere raggiungibile da internetIl client si connette verso l’esterno; nessun endpoint in ingresso
Casi d’uso tipiciPagamenti, CI/CD, depositi, stato degli ordiniChat, dashboard, multiplayer, presenza

La conseguenza pratica: i webhook spostano il problema della consegna sul mittente (con ritentativi che il vostro gestore deve trattare in modo idempotente), mentre i WebSocket spostano su di voi il problema della gestione delle connessioni. Nessuna delle due opzioni è in astratto “più semplice”. Dipende dal fatto che si preferisca scrivere un gestore HTTP senza stato oppure far girare un pool di connessioni con stato.

Quando usare i webhook e quando i WebSocket?

Si verificano queste domande prima di scegliere un’architettura:

  1. Da dove nasce l’evento? Se proviene da un sistema di terze parti (un gateway di pagamento, una rete blockchain, un host Git), servono i webhook. Non si può aprire un WebSocket verso un servizio che non si controlla.
  2. Quanta latenza si può tollerare? Gli aggiornamenti dell’interfaccia sotto il secondo favoriscono i WebSocket. Un ritardo di qualche secondo per l’aggiornamento di un record nel backend va bene con i webhook.
  3. Qual è la forma della scala? Molti produttori di eventi indipendenti che alimentano un solo backend favoriscono i webhook. Un backend che distribuisce aggiornamenti a migliaia di client connessi favorisce i WebSocket.
  4. Qual è la topologia del server? Le funzioni serverless che scalano a zero si abbinano naturalmente ai webhook. Se si gestiscono già server stateful a vita lunga, i WebSocket aggiungono meno complessità incrementale.
  5. Vincoli di firewall o di rete bloccano le connessioni in ingresso? Se l’infrastruttura non può esporre un endpoint pubblico, i WebSocket (che il client avvia verso l’esterno) aggirano completamente il problema.

Applicato agli scenari: le notifiche di pagamento e gli avvisi di deposito vanno sui webhook. L’ingestione di eventi analitici da strumenti esterni va sui webhook. La chat e la modifica collaborativa vanno sui WebSocket. Una dashboard di trading in tempo reale usa i WebSocket per l’ultimo tratto, anche se il flusso dei prezzi sottostante arriva tramite webhook.

Consiglio pratico: Iniziare i prototipi con webhook e un semplice polling sul frontend. È più lento, ma permette di validare il modello degli eventi prima di investire nella gestione delle connessioni. Aggiungere i WebSocket solo dopo aver confermato che gli utenti hanno davvero bisogno di aggiornamenti sotto il secondo, e non prima.

Scalabilità e aspetti operativi

I WebSocket cambiano il calcolo della capacità. Ogni connessione aperta occupa un file descriptor e una porzione di memoria. Oltre una singola istanza del server servono sticky session o un livello pub/sub condiviso, così che i messaggi raggiungano i client indipendentemente dall’istanza a cui sono connessi. È infrastruttura reale, non un’opzione di configurazione.

I webhook scalano in modo diverso, perché non mantengono stato tra una chiamata e l’altra, ed è proprio per questo che si adattano agli ambienti serverless e a scala zero. Una funzione si avvia, elabora la POST e scompare.

Con volumi di produzione, alcuni schemi mantengono sostenibili entrambi i modelli:

  • Instradare i webhook in ingresso attraverso una coda (SQS, Pub/Sub, RabbitMQ), così che un picco di eventi non sovraccarichi il gestore
  • Raggruppare o ritardare (debounce) le trasmissioni WebSocket quando molti eventi si attivano in una finestra breve
  • Usare le dead-letter queue per le consegne di webhook che falliscono ripetutamente l’elaborazione idempotente
  • Monitorare il ricambio delle connessioni sui server WebSocket e la profondità delle code di ritentativo sul lato webhook; entrambi sono segnali precoci prima che i clienti se ne accorgano

Differenze di sicurezza e difese consigliate

Webhook e WebSocket falliscono in modi diversi, quindi richiedono difese diverse. La sicurezza dei webhook ruota attorno alla prova che la richiesta sia autentica: firme HMAC in un header, un timestamp per bloccare gli attacchi di replay e TLS rigoroso. La sicurezza dei WebSocket ruota attorno alla connessione stessa. Il WebSocket Security Cheat Sheet di OWASP afferma che i WebSocket non hanno un’autenticazione integrata, indica di validare l’header Origin a ogni handshake confrontandolo con una allowlist, e avverte di non usare connessioni ws:// non cifrate in produzione. Segnala inoltre che i messaggi possono contenere payload di injection, quindi vanno validati anche dopo l’autenticazione.

Difese pratiche da integrare fin dal primo giorno:

  • Ruotare periodicamente i segreti HMAC e registrare ogni tentativo di consegna con lo stato della firma
  • Rifiutare i payload dei webhook con timestamp obsoleti per bloccare il replay, quando il provider firma un timestamp
  • Usare wss:// e validare l’header Origin a ogni handshake WebSocket
  • Limitare le connessioni WebSocket simultanee per client e la frequenza dei messaggi
  • Validare i payload lato server anche dopo l’autenticazione, perché un token valido non garantisce un messaggio valido

Chaingateway firma i webhook con un HMAC nell’header X-Signature dopo che è stato impostato un segreto personale nel profilo, come descrive la guida alla sicurezza dei webhook. Rigenerare il segreto ha effetto immediato, quindi va aggiornato contemporaneamente anche il ricevitore. La firma è costruita a partire dall’ID della transazione e dal segreto, e non contiene un timestamp, quindi la protezione dal replay deve venire dalla deduplicazione sull’ID della transazione. Il nostro articolo sulla funzione ne illustra il contesto.

Un pattern reale: webhook che alimentano la distribuzione via WebSocket

Un singolo evento attraversa una coda e poi si dirama verso tre client connessi

Il pattern che ricorre in produzione è questo: ricevere un webhook, verificarlo, metterlo in coda, poi far distribuire il risultato dal worker ai client connessi tramite WebSocket. Offre la durabilità della consegna HTTP almeno una volta sul lato di ingestione e la bassa latenza di una connessione persistente sul lato dell’interfaccia.

I passaggi sono questi:

  • Ricevere la POST del webhook e verificare la firma HMAC prima di toccare il payload
  • Mettere in coda l’evento verificato, così che un worker lento a valle non blocchi mai la risposta HTTP
  • Elaborare l’evento (aggiornare un record del database, segnare un pagamento come confermato)
  • Pubblicare il risultato su un canale pub/sub o su un broker a cui si iscrivono i server WebSocket
  • Inviare l’aggiornamento a ogni client connesso e interessato a quell’evento

Questo disaccoppia l’ingestione dalla distribuzione: i webhook sono il meccanismo in ingresso, un broker sta al centro, e i WebSocket gestiscono l’ultimo tratto verso un browser o un’app. Le notifiche di eventi via webhook di Chaingateway consegnano notifiche decodificate e firmate con HMAC, il che elimina un passaggio da questa pipeline, perché non è necessario analizzare i dati grezzi della blockchain prima di agire.

Scelte predefinite e cosa osservare dopo

Per tutto ciò che avviene tra server si sceglie per default i webhook, soprattutto su infrastrutture serverless dove tenere aperta una connessione non ha alcun senso architettonico. Per default si sceglie i WebSocket quando una persona guarda lo schermo in attesa che qualcosa cambi entro un secondo. La maggior parte dei sistemi reali finisce per combinare entrambi invece di sceglierne uno in modo dogmatico, e questo non è un compromesso: di solito è il progetto corretto.

Conviene tenere d’occhio WebTransport e WebSocketStream. Nessuno dei due ha ancora sostituito del tutto i WebSocket, ma entrambi affrontano le lacune di contropressione e gestione degli stream che rendono il codice WebSocket grezzo più difficile da scrivere correttamente di quanto dovrebbe essere.

Ottenere una consegna affidabile dei webhook senza costruirla da sé

Costruire l’ingestione, la verifica e la logica di ritentativo per i webhook richiede tempo di ingegneria reale. I webhook blockchain di Chaingateway inviano notifiche di eventi decodificate e firmate con HMAC per Ethereum, Tron, Bitcoin, Polygon, BNB Chain e Arbitrum, quindi il pattern di distribuzione descritto sopra parte da un payload già verificato. Solana non ha webhook, quindi lì si interrogano gli endpoint del saldo e delle transazioni.

Screenshot della homepage di Chaingateway con il titolo L'API blockchain unificata per pagamenti crypto e webhook

Chaingateway gestisce la creazione e la firma dei webhook, ed elenca le notifiche fallite in modo da poterle inviare di nuovo. La coda e la distribuzione via WebSocket verso i propri utenti restano a carico di chi integra. I piani partono da 49 € al mese (490 € all’anno) con una prova gratuita di 7 giorni che non richiede carta di credito, e la pagina dei prezzi elenca i livelli.

Fonti

Consigliati

Scritto con l’IA di BabyLoveGrowth

Domande frequenti

Nulla ha ancora sostituito completamente i WebSocket, ma WebTransport e WebSocketStream sono alternative emergenti progettate per gestire la contropressione e gli stream multiplexati in modo più pulito. Il supporto dei browser è ancora incompleto, quindi oggi i WebSocket restano l’opzione predefinita per la maggior parte delle funzioni in tempo reale.

Le risposte in streaming delle IA nei browser usano comunemente i Server-Sent Events (SSE) per lo streaming unidirezionale dei token, perché il client deve soprattutto ricevere dati continui, non inviarli. Alcune funzioni vocali in tempo reale o interattive a più turni usano invece i WebSocket, dove lo scambio bidirezionale conta di più.

I webhook richiedono un endpoint raggiungibile pubblicamente, il che solleva questioni di firewall e di sicurezza, e la consegna è in genere almeno una volta, quindi il gestore deve tollerare eventi duplicati. Se l’endpoint è inattivo quando si attiva un evento e i ritentativi scadono, quell’evento può andare perso in silenzio, a meno che non si costruisca un monitoraggio dedicato.

Esempi comuni sono le notifiche di conferma di pagamento, gli eventi di push e pull request di Git, i trigger delle pipeline CI/CD e gli avvisi di deposito o di transazione sulle reti blockchain. L’elaborazione dei depositi via webhook di Chaingateway è un esempio concreto di automazione delle conferme dei fondi senza interrogare un nodo blockchain.

I piani Chaingateway partono da 49 € al mese (490 € all’anno), e ogni piano inizia con una prova gratuita di 7 giorni che non richiede carta di credito. La pagina dei prezzi elenca cosa include ciascun livello.

Come scriviamo questi articoli

Pronto a costruirlo da solo? Ottieni la tua API key — prova di 7 giorni, senza carta — oppure consulta Blockchain API per il riferimento completo degli endpoint.

C
Chaingateway Team
Esperti di blockchain

Il team di Chaingateway si impegna a semplificare l'integrazione blockchain per sviluppatori di tutto il mondo.