HTTP/3 per il mio blog e Nextcloud: un interruttore, due freni nascosti e cosa mostrano le misure
HTTP/3 sul mio ingress Kubernetes: come funziona senza un'opzione ufficiale, cosa lo rallentava all'inizio e perché l'ho spento di nuovo dopo un giorno per via di connessioni bloccate.

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski
Aggiornamento del 6 novembre 2026: qui HTTP/3 è di nuovo attivo, con nginx mainline e quic_bpf. La storia è nel post sulla migrazione.
Aggiornamento, 4 novembre 2026: HTTP/3 è di nuovo spento su tutti i miei server. Il motivo è alla fine di questo post.
Molti utenti delle mie istanze Nextcloud usano il telefono. È esattamente lo scenario per cui è nato HTTP/3: gira su QUIC invece che su TCP, ha bisogno di un round trip in meno per aprire una connessione, gestisce meglio la perdita di pacchetti e può tenere viva una connessione quando il telefono passa dal Wi-Fi ai dati mobili. Il mio obiettivo però non era “avere HTTP/3”, ma: HTTP/3 solo se aiuta in modo misurabile – più throughput o una connessione più stabile su una rete scadente.
Questo post descrive come l’ho attivato, come dimostro che funziona davvero – e i due freni che all’inizio rendevano HTTP/3 nettamente più lento di HTTP/2.
Indice
🧒 Per chi non è del mestiere: cos’è HTTP – e perché all’improvviso UDP?
HTTP è la lingua tra browser e web server. Il browser chiede “dammi questa pagina”, il server la manda. Ogni immagine, ogni testo e ogni file in Nextcloud passa di qui. Ma HTTP definisce solo cosa viene detto. Come i dati attraversano la rete lo gestisce uno strato sottostante – e ci sono due metodi:
| TCP | UDP | |
|---|---|---|
| Paragone | Raccomandata: la ricezione viene confermata, ciò che si perde viene rispedito | Cartolina: la spedisci e via, nessuna conferma |
| Ordine | arriva sempre nell’ordine giusto | nessuna garanzia |
| Apertura connessione | prima una stretta di mano, che richiede tempo | nessuna, si parte subito |
| In caso di perdita di pacchetti | tutto ciò che segue aspetta il pezzo mancante | UDP di per sé non se ne accorge |
| Tipico per | siti web (finora), e-mail, file | DNS, videochiamate, giochi |
HTTP/1.1 e HTTP/2 girano su TCP. Solo HTTP/3 gira su UDP – più precisamente su QUIC, che sta sopra UDP e si occupa da sé dell’affidabilità: anche con QUIC non si perde nulla, solo che rispedisce in modo più furbo.
Perché tanta fatica? Se con HTTP/2 si perde un solo pacchetto, su TCP tutti i file della pagina lo aspettano. Con HTTP/3 aspetta solo il file interessato. Una connessione TCP è inoltre legata all’indirizzo IP: quando il telefono passa dal Wi-Fi ai dati mobili, si interrompe. QUIC ha un proprio ID di connessione e può proseguire. Sono esattamente le situazioni di un telefono in giro.
Il succo: HTTP/3 non è un nuovo web, ma lo stesso contenuto su un trasporto che regge meglio le reti scadenti.
🔌 Il controller non può – il suo nginx sì
Il mio ingress è il NGINX Ingress Controller di F5. Non ha alcuna opzione per HTTP/3: nessun interruttore, nessuna chiave nella ConfigMap, niente nelle release notes. Uno sguardo dentro il pod in esecuzione mostra però che l’nginx 1.31.7 incluso è compilato con --with-http_v3_module, insieme a OpenSSL 3.5, la prima release di OpenSSL che fa QUIC lato server. E poiché il controller gira con hostNetwork, nginx può aprire direttamente UDP 443.
Quindi passo dagli snippet che uso già:
# server-snippets of the main site (once per address):
listen 443 quic reuseport rcvbuf=4m sndbuf=4m;
listen [::]:443 quic reuseport rcvbuf=4m sndbuf=4m;
# http-snippets of the controller:
map $scheme $http3_alt_svc {
https 'h3=":443"; ma=604800';
default "";
}
http3_stream_buffer_size 1m;
quic_gso on;
# next to the other security headers (location-snippets):
add_header Alt-Svc $http3_alt_svc always;
reuseportsolo una volta per indirizzo: nginx consente questa opzione in una sola rigalistenper indirizzo e porta. Quindi sta solo nel server block del sito principale, e tutti gli altri host condividono quei socket.- Alt-Svc solo su HTTPS: questo header dice ai browser che esiste HTTP/3. La
maplo imposta solo per HTTPS; sulla porta 80 il valore resta vuoto e nginx allora non manda alcun header. - Alt-Svc accanto agli altri header: nginx non eredita
add_headerappena una location imposta header propri. I miei security header stanno negli snippet delle location – quindi anche Alt-Svc deve andare lì. - Firewall: UDP 443 in ingresso per IPv4 e IPv6. In uscita non serve alcuna regola; le risposte sono “established” per conntrack.
Tutto dipende da un interruttore per host (ingress_http3_enabled), spento di default. Ho acceso prima il blog, poi il Nextcloud più piccolo. Prima del run vero ho verificato le nuove righe con nginx -t su una copia della configurazione dentro il pod.
Il succo: “non supportato” a volte significa solo “non ha un interruttore”. nginx -V mostra cosa sa fare davvero il binario.
🤔 Perché ho creduto così a lungo che HTTP/3 fosse impossibile
L’avevo già verificato una volta, ad agosto – con il risultato “non possibile”. Ed era quello che diceva da allora anche un commento nel mio template del firewall. Allora avevo controllato due cose: il controller ha un’opzione per HTTP/3? No. Il server risponde su HTTP/3? No, ovviamente – non c’era alcun listener QUIC.
Quello che non avevo controllato: se l’nginx del controller contenesse proprio il modulo. La conclusione “nessuna opzione, quindi nessun supporto” era troppo frettolosa. Se l’immagine di allora avesse già il modulo oggi non si può più ricostruire – quella attuale ce l’ha, insieme a una versione di OpenSSL che fa QUIC lato server. Solo la domanda “cosa sa fare il binario?” invece di “cosa offre la configurazione?” ha portato all’altra risposta.
Il succo: un “non possibile” merita una data e un motivo – e un secondo controllo quando il software è cambiato.
✅ Come vedere che HTTP/3 funziona davvero
Una pagina che si carica non dice nulla sul protocollo. Dopo ogni attivazione ho eseguito questi controlli:
curl -sI --http2 https://www.apt-upgrade.me/ | grep -i alt-svc
alt-svc: h3=":443"; ma=604800
curl -s --http3-only -o /dev/null -w '%{http_code} h%{http_version}\n' https://www.apt-upgrade.me/
200 h3
- HTTP/3 forzato con
curl --http3-onlysu ogni percorso importante: home page, login,status.phpdi Nextcloud, l’API OCS, WebDAV, Collabora – ovunque la risposta attesa su h3. - Stesso contenuto: un grosso file JavaScript caricato su HTTP/2 e HTTP/3 – checksum SHA-256 identico. Anche gli header di risposta sono gli stessi.
- Lato server:
ss -ulnpmostra un socket UDP per worker nginx sulla porta 443, IPv4 e IPv6; l’access log mostra richieste conHTTP/3.0. - Dall’esterno: http3check.net conferma QUIC versione 1 e HTTP/3, testato su IPv6 – che da casa non posso proprio testare.
- Sicurezza invariata: i filtri di fail2ban riconoscono le righe di login con
HTTP/3.0esattamente come conHTTP/2.0. I dati 0-RTT early data restano spenti, così nessuno può riprodurre un form di login.
Una piccola trappola: il mio primo test di fail2ban è fallito – con una riga di log fatta a mano nel formato sbagliato. Con una riga vera presa dal log, cambiando solo il protocollo, il filtro ha fatto match subito.
Il succo: una prova ha bisogno di più angolazioni – client, server, un terzo dall’esterno e i tuoi stessi strumenti di sicurezza.
🐢 Freno 1: 64 KB per round trip
Le richieste piccole erano subito altrettanto veloci o più veloci su HTTP/3. Poi è arrivato il test con un file grande: 5,7 MB hanno richiesto 0,18 secondi su HTTP/2 e 0,99 secondi su HTTP/3 – più di cinque volte tanto.
Il client usava a malapena la CPU; stava aspettando. Il calcolo ha portato alla causa: di default nginx bufferizza solo 64 KB per stream QUIC (http3_stream_buffer_size). Uno stream non può avere più di tanto in volo. 64 KB per round trip a 11 ms fanno esattamente i 5,8 MB/s misurati. Su una connessione mobile con 50 ms sarebbe circa 1,3 MB/s – quindi HTTP/3 avrebbe rallentato i miei utenti in giro.
Con un buffer da 1 MB, i download su HTTP/3 andavano a 27–31 MB/s, alla pari con HTTP/2.
Il succo: un nuovo protocollo porta nuovi default. È bastato un solo test con un file grande per trovare il freno – ed è per questo che fa parte di ogni test di collaudo.
🧺 Freno 2: un buffer del socket che trabocca
Poi l’altra direzione: un upload da 20 MB. HTTP/3 faceva in media 7,8 MB/s, HTTP/2 11,9 MB/s – e nel frattempo il server contava 284 pacchetti UDP scartati (RcvbufErrors in /proc/net/snmp).
Il motivo sta nella differenza rispetto a TCP. Con TCP il kernel gestisce da sé flusso e buffer. QUIC invece gira nell’applicazione, su UDP: ogni pacchetto aspetta nel buffer di ricezione del socket finché nginx non lo prende. Di default Linux dà a un socket al massimo 208 KB – un upload veloce lo riempie, e il kernel butta via i pacchetti successivi. QUIC deve rispedirli e si rallenta da solo.
La soluzione ha due parti:
- Alzare il limite del kernel:
net.core.rmem_maxenet.core.wmem_maxa 7,5 MB – il valore raccomandato dalle implementazioni QUIC. Questo alza solo il tetto; tutti gli altri socket mantengono il loro default. - Richiedere i buffer: i listener QUIC chiedono da sé buffer più grandi con
rcvbuf=4m sndbuf=4m. Il kernel raddoppia il valore internamente;ss -mmostra poi 8 MB per socket.
Dopo: 0 pacchetti scartati, e gli upload su HTTP/3 erano al livello di HTTP/2 – la variazione rimanente veniva dal mio uplink.
Il succo: se fai girare UDP ad alto throughput, devi conoscere i buffer dei tuoi socket. Il kernel conta i pacchetti scartati – devi solo guardare.
📊 Le misure
Ho misurato dal mio homelab con curl, 15 connessioni nuove per valore (mediana). Il blog è più lontano (circa 42 ms per round trip), il Nextcloud più vicino (circa 11 ms).
| Misura | HTTP/2 | HTTP/3 |
|---|---|---|
| Blog: connessione + cifratura pronte | 96 ms | 58 ms |
| Blog: primo byte della home page | 139 ms | 104 ms |
| Blog: home page completa | 268 ms | 227 ms |
| Nextcloud: connessione + cifratura pronte | 31 ms | 27 ms |
| Nextcloud: download da 5,7 MB, buffer di default | 34 MB/s | 5,8 MB/s |
| Nextcloud: download da 5,7 MB, stream buffer da 1 MB | 28 MB/s | 30 MB/s |
| Nextcloud: upload da 20 MB, socket buffer da 208 KB | 11,9 MB/s | 7,8 MB/s |
| Nextcloud: upload da 20 MB, socket buffer da 8 MB | 15,1 MB/s | 13,0 MB/s |
| Nextcloud: upload da 100 MB, socket buffer da 8 MB | 8,7 MB/s | 7,7 MB/s |
| Collabora: richiesta di discovery (47 KB) | 55–72 ms | 57 ms |
A 100 MB il mio uplink limita entrambi i protocolli allo stesso modo, senza pacchetti scartati. Download più grandi non si potevano testare senza un account utente: il file più grande raggiungibile pubblicamente sul Nextcloud è il file di script da 5,7 MB. Collabora modifica i documenti tramite WebSocket, che continuano a girare su TCP – l’unica cosa da misurare lì è la richiesta di discovery.
Il guadagno nell’apertura della connessione è un round trip: TCP e TLS ne servono due, QUIC fa entrambe le cose in uno. Per il blog a 42 ms sono circa 40 ms per ogni nuova connessione; per il Nextcloud vicino quasi niente. Sulle reti mobili con 50–100 ms il guadagno è proporzionalmente maggiore.
Il succo: HTTP/3 fa risparmiare soprattutto tempo di attesa, non banda. Più l’utente è lontano, più aiuta.
🔧 Le manopole rimanenti
quic_gso on: nginx passa al kernel più pacchetti QUIC alla volta invece di uno per chiamata. Questo risparmia CPU in invio; le mie schede di rete virtuali lo fanno in software, il che aiuta comunque. Attivato.- Alt-Svc per 7 giorni invece di 1: i visitatori che tornano partono direttamente su HTTP/3 più a lungo. Se più avanti HTTP/3 viene spento, ogni browser perde al massimo un tentativo – ripiega da solo su HTTP/2. Impostato.
quic_bpf: fa sì che i pacchetti di una connessione arrivino al worker nginx giusto dopo un cambio di rete. Per questo nginx deve caricare un programma eBPF, che richiede privilegi extra (CAP_BPF,CAP_NET_ADMIN) – proprio nel container che è esposto su internet e che di proposito ha una sola capability. Non attivato: se una migrazione fallisce, il telefono semplicemente si riconnette, con QUIC in un round trip.- 0-RTT (
ssl_early_data): risparmierebbe un altro round trip sulle connessioni ricorrenti, ma tali richieste possono essere riprodotte – login compresi. Resta spento.
Il succo: ogni manopola ha un prezzo. Quello che costa poco si accende; quello che indebolisce l’hardening resta spento, anche se sulla carta sembra più veloce.
🔤 Una scoperta collaterale: font che gzip rendeva più grandi
Non c’entra direttamente con HTTP/3, ma l’ho notato durante le misure di performance. I file di font WOFF2 sono compressi per design, quindi contengono già dati compattati. La mia configurazione nginx aveva comunque font/woff2 nella lista dei tipi di file che vengono gzippati in aggiunta.
Misurato sul blog: 18.652 byte sono diventati 18.680 byte. Il server ha fatto il lavoro e il file è cresciuto di 28 byte. Così ho rimosso la voce sia per il blog sia per Nextcloud; testo, CSS e JavaScript restano compressi. File ZIP e immagini non sono mai stati nella lista. Non è un guadagno di velocità percepibile, solo un lavoro inutile in meno.
gzip_types
text/plain text/css text/xml text/javascript
application/javascript application/json application/xml
application/rss+xml image/svg+xml; # font/woff2 removed
Il succo: comprimere qualcosa che è già compresso costa tempo di CPU e non porta nulla. Liste come questa meritano una seconda occhiata, anche quando tutto funziona.
🧭 Dalla prima visita: il record HTTPS nel DNS
Alt-Svc ha un difetto: un browser viene a sapere di HTTP/3 solo dalla prima risposta. La primissima visita quindi passa sempre su HTTP/2. Un record DNS dedicato di tipo HTTPS (RFC 9460) risolve il problema: comunica al browser, durante la risoluzione del nome, quali protocolli parla il server.
# DNS zone (example): HTTPS record, priority 1, "." = same name
www.example.org. 3600 IN HTTPS 1 . alpn="h3,h2"
# check it:
dig +short HTTPS www.example.org
1 . alpn="h3,h2"
L’1 è la priorità, il punto significa “lo stesso nome”, e alpn elenca i protocolli nell’ordine preferito. Lascio fuori di proposito gli IP hint – andrebbero mantenuti a ogni cambio di indirizzo. Chrome, Firefox e Safari usano il record. Non tutte le interfacce di gestione DNS offrono questo tipo, quindi conviene verificarlo prima di chiedersi perché manca.
È proprio il mio caso: la gestione DNS del mio provider offre solo record A, AAAA, CNAME, MX, NS, TXT e SRV – lì non posso impostare un record HTTPS. Non si può nemmeno emulare; i browser usano solo il tipo vero. Così il blog è rimasto con Alt-Svc: la prima visita passava su HTTP/2, ogni visita successiva andava direttamente su HTTP/3 per sette giorni. Cambiare provider DNS solo per questo non ne varrebbe la pena, per me.
Il succo: il server può solo offrire HTTP/3. Se il browser lo usa già alla primissima visita dipende dal DNS.
📱 Cosa porta ai miei utenti – e cosa no
- Browser sui telefoni: il guadagno maggiore – apertura più rapida, nessuno stallo di tutte le richieste quando si perde un pacchetto, e la connessione sopravvive al passaggio tra Wi-Fi e dati mobili.
- App Nextcloud su iPhone: iOS usa HTTP/3 da solo non appena il server lo annuncia tramite Alt-Svc. Il log lo conferma, vedi sotto.
- App Android e client desktop: secondo il log finora non parlano HTTP/3, vedi sotto.
- Collabora e notify_push: girano su WebSocket. nginx non sa fare WebSocket su HTTP/3, quindi queste connessioni restano su HTTP/1.1 su TCP – funziona, solo senza il vantaggio.
Quello che da qui non potevo misurare è il comportamento su una rete scadente. Sarebbe stato il test successivo: con un telefono in una zona con poca copertura, HTTP/3 acceso e spento a confronto.
Il succo: sii onesto su chi ne trae beneficio. Un aggiornamento di protocollo aiuta solo i client che lo parlano.
📈 I primi numeri: 13 ore nel log
Un primo sguardo agli access log, da ieri sera a stamattina – quindi soprattutto di notte, con traffico corrispondentemente scarso. Sono contati solo browser e app Nextcloud; bot, script e i miei test sono esclusi.
| Server | Richieste | HTTP/3 | HTTP/2 | HTTP/1.1 |
|---|---|---|---|---|
| Blog | 2.033 | 12,3 % | 67,0 % | 20,7 % |
| Nextcloud grande | 1.560 | 45,6 % | 23,5 % | 30,9 % |
| Nextcloud piccolo | 193 | 0 % | 43,0 % | 57,0 % |
| Totale | 3.786 | 25,4 % | 47,8 % | 26,8 % |
Su HTTP/3 in quel periodo non c’è stato un solo errore del server (5xx) e solo un’interruzione da parte del client su 962 richieste. Il kernel non ha scartato pacchetti UDP.
📲 Chi sa fare HTTP/3 – e chi lo usa davvero?
La colonna “Lo sa fare” viene dalla documentazione (caniuse), la colonna “Nel log” dai miei server:
| Client | Lo sa fare | Nel log: quota HTTP/3 | Richieste |
|---|---|---|---|
| App Nextcloud iPhone | sì, tramite il sistema iOS | 88,1 % | 748 |
| Firefox desktop | sì, dalla versione 88 | 64,4 % | 399 |
| Chrome Android | sì | 14,0 % | 301 |
| Safari macOS | sì, dalla versione 16 | 4,8 % | 83 |
| Chrome desktop | sì, dalla versione 87 | 0 % | 1.295 |
| Safari iPhone | sì, da iOS 16 | 0 % | 312 |
| Edge | sì, dalla versione 87 | 0 % | 111 |
| App Nextcloud Android | non nel log | 0 % | 210 |
| Client desktop Nextcloud | non nel log | 0 % (tutto HTTP/1.1) | 321 |
Spicca l’app per iPhone: parla HTTP/3 senza che nessuno configuri nulla, perché iOS lo gestisce a livello di sistema. L’app Android e il client desktop non lo usano affatto. Su Android probabilmente dipende dalla libreria di rete: OkHttp, molto diffusa su Android, da sola non sa fare HTTP/3. Se sia esattamente questo a fermare l’app, non l’ho verificato nel suo codice sorgente.
Lo 0 % per Chrome desktop e Safari iPhone va letto con cautela. Molte richieste con questi identificativi vengono da bot che si spacciano per browser – un vero Chrome praticamente non parla mai HTTP/1.1 su HTTPS. Inoltre un browser viene a sapere di HTTP/3 solo dalla prima risposta e poi resta sulla connessione aperta. Quindi chi legge un solo articolo resta su HTTP/2. La versione mobile dimostra che Chrome in linea di principio funziona.
Il succo: il supporto sulla carta dice poco. Solo il log mostra chi parla davvero un protocollo – e da me è soprattutto l’app per iPhone.
📅 Stato e prospettive
Il 3 novembre HTTP/3 girava su tutti e tre i server: il blog e entrambe le istanze Nextcloud. Ho collaudato il secondo Nextcloud con gli stessi controlli del primo, e il drift check riporta changed=0 ovunque – i server corrispondono esattamente al codice nel repository pubblico.
Il piano era guardare tre cose dopo una settimana:
- Uso: quale quota delle richieste nell’access log arriva su
HTTP/3.0– suddivisa per browser, app Nextcloud e client di sincronizzazione? - Errori: ci sono più risposte di errore o upload interrotti su HTTP/3 che su HTTP/2?
- Pratica: come si comporta il Nextcloud su un telefono con poca copertura, con e senza HTTP/3?
Non ci si è arrivati: un giorno dopo ho spento di nuovo HTTP/3, quindi la valutazione e il post separato saltano. Il motivo è nell’aggiornamento alla fine. Come previsto, tornare indietro ha richiesto un interruttore e un run del playbook.
🎯 Le lezioni
- Prima verifica cosa sa fare il binario – “nessuna opzione” non significa “nessun modulo”.
- Testa con file grandi, in entrambe le direzioni – le richieste piccole nascondono ogni freno al throughput.
- I buffer UDP fanno parte di QUIC –
RcvbufErrorsmostra se il kernel sta scartando pacchetti. - Testa con righe di log vere – un esempio fatto a mano testa solo l’esempio.
- Accendilo perché aiuta – misurato, non presunto, e con un interruttore che si può rimettere indietro.
🔄 Aggiornamento, 4 novembre 2026: HTTP/3 si spegne di nuovo
In breve: un giorno dopo questo post ho trovato un bug vero. I download su HTTP/3 sul Nextcloud grande si bloccavano in circa l'11 % dei run. La causa è stata trovata e confermata da un controtest. Quindi ho spento di nuovo HTTP/3, su entrambi i Nextcloud e, la sera stessa, anche sul blog. Stabilità e affidabilità contano per me più di un nuovo protocollo di cui finora non sono riuscito a misurare il beneficio.
Come si è manifestato. In realtà volevo testare se uno stream buffer ancora più grande aiutasse. Così ho ripetuto la misura con molti più run, e all’improvviso singoli run si fermavano a 0 MB/s. curl riportava HTTP/3 stream 0 reset by server, e il log del server mostrava un’interruzione dopo 60 secondi. Su HTTP/2 non è successo nemmeno una volta. Il giorno prima non l’avevo notato: avevo fatto solo 8 run di download, e il fattore scatenante probabilmente è comparso solo dopo.
La pista sbagliata. I blocchi erano sorprendentemente spesso esattamente a 523.559 byte. Con probabilmente 729 byte di protocollo in più, fanno esattamente 512 KiB, la finestra iniziale dello stack QUIC di OpenSSL, che usa il mio curl. Nella cattura il server smetteva di mandare dopo 0,37 secondi ed entrambe le parti tacevano. All’inizio l’ho preso per un problema del client di test e l’avevo anche annotato così. Era sbagliato. Il controtest con altre due implementazioni QUIC ha mostrato questo:
| Client | Nextcloud grande | Nextcloud piccolo |
|---|---|---|
| curl con OpenSSL | 15 su 117 bloccati | 0 su 32 |
| curl con quiche | 3 su 40 | 0 su 40 |
| aioquic | 3 su 40 | 0 su 25 |
Quindi tre client diversi si bloccano solo su uno dei due server. Questo spostava la colpa sul server, non sul client.
La causa. Sul Nextcloud grande girava un vecchio worker nginx che non avrebbe più dovuto esserci:
$ ps -eo args | grep 'shutting down'
nginx: worker process is shutting down
Questo stato all’inizio è normale. Quando nginx fa un reload, partono nuovi worker e quelli vecchi terminano le connessioni in corso. Qui il reload faceva parte di un normale rollout. Ma il vecchio worker teneva il websocket di un client verso notify_push, il servizio push di Nextcloud. Una connessione del genere non finisce da sola, e io non avevo impostato alcun limite di tempo. Quindi il worker sarebbe probabilmente rimasto in esecuzione a tempo indeterminato.
Con TCP questo non fa danni, perché ogni connessione ha il suo socket. Con QUIC tutte le connessioni condividono i socket UDP. Il vecchio worker teneva aperti questi socket e a quanto pare poteva anche intercettare pacchetti destinati ai nuovi worker. Questo torna con i numeri: con 8 worker dovrebbe colpire circa 1 connessione su 8, e io ne ho misurate 21 su 197, circa l'11 %. Ho ricavato la sequenza dapprima dalle misure. Uno sviluppatore di nginx descrive lo stesso meccanismo nella Issue #1399 e l’ha riprodotto.
La prova. Ho terminato solo questo vecchio worker e ripetuto tutto. Risultato: 0 run bloccati su 200, con tutti e tre i client, contro i 21 su 197 di prima. Il Nextcloud piccolo e il blog non avevano un worker del genere e non mostravano blocchi nemmeno loro; sul blog erano 0 su 120 richieste su HTTP/3.
Di chi è la colpa? HTTP/3 non è fondamentalmente incompatibile con il mio setup; senza un vecchio worker tutto girava pulito. Il problema è una debolezza nota di nginx durante i reload, descritta nella issue #425. La issue è stata chiusa a ottobre, e secondo il changelog l’nginx 1.31.7 che uso gestisce i reload con QUIC, ma solo con quic_bpf. Quello l’avevo lasciato fuori di proposito. Il mio setup ci mette del suo: il controller F5 non ha un’opzione HTTP/3 propria, l’ho abilitato io tramite snippet, e notify_push tiene in vita i vecchi worker.
Cosa ho verificato e scartato:
- Un Ingress Controller più recente: uso già la versione più nuova, la 5.7.0. Non c’è un aggiornamento.
quic_bpf: la soluzione di nginx stesso, ma il lato sicurezza al momento non mi convince. Il container dell’ingress gira senza root e può solo fare bind su porte basse come la 443. Conquic_bpfavrebbe bisogno anche diCAP_BPFeCAP_NET_ADMIN, perché nginx carica un programma eBPF nel kernel per farlo. Questo container è esposto direttamente su internet e gira nella rete dell’host. Chi riuscisse a entrarci potrebbe usareCAP_NET_ADMINper cambiare anche le impostazioni di rete del server. Per un beneficio che finora non sono riuscito a misurare, per me è uno scambio troppo svantaggioso.worker-shutdown-timeout: termina i vecchi worker dopo un tempo fisso. Fino ad allora il bug resta, e dopo interrompe anche download e upload grandi in corso. Su un Nextcloud è un cattivo scambio. L’ho testato per il blog, più sotto i dettagli.- Kernel o nftables: il kernel non conosce worker “vecchi”, ed entrambi i worker condividono lo stesso socket. Nessuna regola del firewall può distribuire i pacchetti tra loro. Uno script che blocca UDP 443 per un po’ sarebbe solo un pezzo in più che può rompersi.
Un attaccante può sfruttarlo? Non ci vedo un attacco utile. QUIC è cifrato, e non ho alcun indizio che dei dati diventino visibili. Il risultato sono connessioni bloccate, quindi un problema puramente di disponibilità. Nemmeno i reload si possono scatenare dall’esterno; avvengono solo durante i miei rollout e i job pianificati. Non è una garanzia, ma con HTTP/3 spento questa strada è comunque chiusa. Googlebot non era coinvolto, tra l’altro: nelle ultime 24 ore è arrivato solo su HTTP/1.1.
Cosa non so: quanti utenti reali sono stati colpiti in quell’unico giorno. Il log mostra pochissime interruzioni su HTTP/3, ma non contiene i tempi di risposta. Un blocco che poi si è comunque concluso più tardi lì sarebbe invisibile. Quindi questo “pochissime” non è nemmeno un cessato allarme. Resta aperto anche quanto velocemente ripieghino i client che si ricordano ancora di HTTP/3: il mio browser ha aperto il Nextcloud normalmente, mentre curl con una voce memorizzata è rimasto bloccato 30 secondi. La risposta per l’app iOS ora è abbastanza chiara. Io non la uso e posso solo contare: entro 20 ore dallo spegnimento, 7 dispositivi iOS erano tornati, senza alcun intervento, e il log che ho controllato non mostrava interruzioni né errori del server. Nessuno dei dispositivi attivi nei tre giorni prima dello spegnimento è sparito da allora. Altri sette dispositivi, che erano già silenziosi da oltre tre giorni prima dello spegnimento, non si sono ancora rifatti vivi; se siano semplicemente usati di rado, il log non lo può dire. Finora Alt-Svc: clear non è stato necessario. Lo tengo d’occhio fino al 12 novembre.
Lo stato dopo il rollout:
# All hosts
ingress_http3_enabled: false
- Entrambi i Nextcloud: HTTP/3 spento. File di lavoro e sincronizzazione dipendono da loro, ed è proprio lì che vivono le connessioni lunghe.
- Blog: ora HTTP/3 è spento anche qui. All’inizio volevo tenerlo con un limite di 5 minuti per i vecchi worker, perché lì i trasferimenti sono brevi. Il test è andato bene: con un vecchio worker creato apposta, 8 richieste su 55 su HTTP/3 si bloccavano. Dopo circa 5 minuti era sparito, e poi 0 su 110 si bloccavano. Un upload volutamente lento è stato interrotto come previsto. Comunque non mi ha convinto del tutto: il bug resta finché il limite non scade, e nella PR #503 un altro gestore riporta, su una versione più vecchia, un vecchio worker che il suo limite non ha terminato.
- Come si prosegue: ho chiesto nella Issue #1937 di nginx se è prevista una soluzione senza i privilegi extra di
quic_bpf, e aspetto la risposta. Guardo anche nei report settimanali degli aggiornamenti se F5 supporta HTTP/3 ufficialmente o se nginx risolve i reload senzaquic_bpf. L’interruttore resta: posso riaccendere HTTP/3 in qualsiasi momento.
Cosa mi porto via:
- Otto run non dimostrano niente. Un bug che colpisce un run su nove sfugge facilmente. Misura l’affidabilità con molti run, non solo la velocità.
- Verifica la prima spiegazione. I 512 KiB tornavano incredibilmente bene e hanno comunque portato fuori strada. Solo un secondo e un terzo client l’hanno mostrato.
- Misura di nuovo dopo ogni reload. Il bug non è comparso all’attivazione, ma durante un rollout successivo, del tutto normale.
- Un interruttore vale oro. Siccome HTTP/3 dipende da un solo interruttore per server, la ritirata è piccola e si può annullare in qualsiasi momento.
- Nuovo non significa migliore. Senza un beneficio misurabile, conta di più l’affidabilità.
