HTTP/3 voor mijn blog en Nextcloud: één schakelaar, twee verborgen remmen en wat de metingen laten zien

HTTP/3 op mijn Kubernetes-ingress: hoe het werkt zonder officiële optie, wat het in het begin afremde – en waarom ik het na één dag weer uitzette vanwege hangende verbindingen.

HTTP/3 uitgeschakeld

🌐 Ook in: English · Deutsch · Français · Español · Italiano · Português · Polski

Update van 6 november 2026: HTTP/3 staat hier weer aan, met nginx mainline en quic_bpf. Het verhaal staat in de migratiepost.

Update, 4 november 2026: HTTP/3 staat op al mijn servers weer uit. De reden staat aan het eind van deze post.

Veel gebruikers van mijn Nextcloud-instanties zitten op hun telefoon. Precies daarvoor is HTTP/3 gebouwd: het draait over QUIC in plaats van TCP, heeft één round trip minder nodig om een verbinding op te zetten, gaat beter om met pakketverlies en kan een verbinding in leven houden als de telefoon van wifi naar mobiele data wisselt. Mijn doel was echter niet “HTTP/3 hebben”, maar: HTTP/3 alleen als het meetbaar helpt – meer throughput of een stabielere verbinding op een slecht netwerk.

Deze post beschrijft hoe ik het heb ingeschakeld, hoe ik bewijs dat het echt draait – en de twee remmen die HTTP/3 in het begin duidelijk trager maakten dan HTTP/2.

Inhoud

🧒 Voor niet-IT-lezers: wat is HTTP – en waarom ineens UDP?

HTTP is de taal tussen browser en webserver. De browser vraagt “geef me deze pagina”, de server stuurt hem. Elke afbeelding, elke tekst en elk bestand in Nextcloud reist via deze weg. Maar HTTP legt alleen vast wat er gezegd wordt. Hoe de data door het netwerk komt, regelt een laag eronder – en daar zijn twee methoden voor:

TCPUDP
VergelijkingAangetekende brief: ontvangst wordt bevestigd, wat kwijtraakt wordt opnieuw verstuurdAnsichtkaart: versturen en doorgaan, geen bevestiging
Volgordekomt altijd in de juiste volgorde aangeen garantie
Verbinding opzetteneerst een handshake, en dat kost tijdgeen, het begint meteen
Bij pakketverliesalles erachter wacht op het ontbrekende stukUDP zelf merkt het niet
Typisch voorwebsites (tot nu toe), e-mail, bestandenDNS, videobellen, games

HTTP/1.1 en HTTP/2 draaien over TCP. Alleen HTTP/3 draait over UDP – preciezer gezegd over QUIC, dat bovenop UDP zit en zelf voor de betrouwbaarheid zorgt: ook bij QUIC raakt niets kwijt, het verstuurt alleen slimmer opnieuw.

Waarom de moeite? Als bij HTTP/2 één enkel pakket kwijtraakt, wachten via TCP alle bestanden van de pagina erop. Bij HTTP/3 wacht alleen het betreffende bestand. Een TCP-verbinding is bovendien aan het IP-adres gebonden: als de telefoon van wifi naar mobiele data gaat, breekt ze af. QUIC heeft een eigen verbindings-ID en kan gewoon doorgaan. Dat zijn precies de situaties van een telefoon onderweg.

De les: HTTP/3 is geen nieuw web, maar dezelfde inhoud op een transport dat beter met slechte netwerken omgaat.

🔌 De controller kan het niet – zijn nginx wel

Mijn ingress is de NGINX Ingress Controller van F5. Die heeft geen optie voor HTTP/3: geen schakelaar, geen ConfigMap-key, niets in de release notes. Een blik in de draaiende pod laat echter zien dat de meegeleverde nginx 1.31.7 gebouwd is met --with-http_v3_module, samen met OpenSSL 3.5, de eerste OpenSSL-release die server-side QUIC doet. En omdat de controller met hostNetwork draait, kan nginx UDP 443 direct openen.

Dus gaat het via de snippets die ik al gebruik:

# 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;
  • reuseport maar één keer per adres: nginx staat deze optie toe in één enkele listen-regel per adres en poort. Daarom staat ze alleen in het serverblok van de hoofdsite, en alle andere hosts delen die sockets.
  • Alt-Svc alleen via HTTPS: deze header vertelt browsers dat er HTTP/3 is. De map zet hem alleen voor HTTPS; op poort 80 blijft de waarde leeg, en dan stuurt nginx helemaal geen header.
  • Alt-Svc naast de andere headers: nginx erft add_header niet zodra een location eigen headers zet. Mijn security-headers staan in de location snippets – dus Alt-Svc moet daar ook in.
  • Firewall: UDP 443 inkomend voor IPv4 en IPv6. Uitgaand is geen regel nodig; de antwoorden zijn voor conntrack “established”.

Alles hangt aan één schakelaar per host (ingress_http3_enabled), standaard uit. Eerst zette ik de blog aan, daarna de kleinere Nextcloud. Voor de echte run controleerde ik de nieuwe regels met nginx -t tegen een kopie van de configuratie in de pod.

De les: “niet ondersteund” betekent soms alleen “heeft geen schakelaar”. nginx -V laat zien wat de binary echt kan.

🤔 Waarom ik zo lang dacht dat HTTP/3 onmogelijk was

Ik had dit al eens eerder gecontroleerd, in augustus – met als resultaat “niet mogelijk”. Dat stond sindsdien ook in een commentaar in mijn firewall-template. Destijds controleerde ik twee dingen: heeft de controller een optie voor HTTP/3? Nee. Antwoordt de server via HTTP/3? Nee, natuurlijk niet – er was geen QUIC-listener.

Wat ik niet had gecontroleerd: of de nginx van de controller de module überhaupt bevat. De conclusie “geen optie, dus geen ondersteuning” was te snel. Of het image toen al de module had, valt vandaag niet meer na te gaan – het huidige heeft hem, samen met een OpenSSL-versie die server-side QUIC doet. Pas de vraag “wat kan de binary?” in plaats van “wat biedt de configuratie?” leidde tot het andere antwoord.

De les: een “niet mogelijk” verdient een datum en een reden – en een tweede controle zodra de software veranderd is.

✅ Hoe je ziet dat HTTP/3 echt draait

Een pagina die laadt zegt niets over het protocol. Na elke inschakeling deed ik deze checks:

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
  • Afgedwongen HTTP/3 met curl --http3-only op elk belangrijk pad: voorpagina, login, de status.php van Nextcloud, de OCS-API, WebDAV, Collabora – overal het verwachte antwoord via h3.
  • Zelfde inhoud: een groot JavaScript-bestand geladen via HTTP/2 en HTTP/3 – identieke SHA-256-checksum. Ook de response-headers zijn gelijk.
  • Serverkant: ss -ulnp toont één UDP-socket per nginx-worker op poort 443, IPv4 en IPv6; de access log toont requests met HTTP/3.0.
  • Van buitenaf: http3check.net bevestigt QUIC versie 1 en HTTP/3, getest via IPv6 – wat ik vanuit huis helemaal niet kan testen.
  • Beveiliging ongewijzigd: de fail2ban-filters matchen loginregels met HTTP/3.0 net zo goed als met HTTP/2.0. 0-RTT early data blijft uit, zodat niemand een loginformulier opnieuw kan afspelen.

Eén kleine valkuil: mijn eerste fail2ban-test faalde – met een zelfgemaakte logregel in het verkeerde formaat. Met een echte regel uit de log, waarin alleen het protocol vervangen was, matchte het filter meteen.

De les: bewijs heeft meerdere invalshoeken nodig – client, server, een derde partij van buitenaf en je eigen securitytools.

🐢 Rem 1: 64 KB per round trip

Kleine requests waren via HTTP/3 meteen even snel of sneller. Toen kwam de test met een groot bestand: 5,7 MB kostte via HTTP/2 0,18 seconde en via HTTP/3 0,99 seconde – ruim vijf keer zo lang.

De client gebruikte nauwelijks CPU; hij wachtte. Het rekenwerk leidde naar de oorzaak: standaard buffert nginx maar 64 KB per QUIC-stream (http3_stream_buffer_size). Meer kan een stream niet onderweg hebben. 64 KB per round trip bij 11 ms is precies de gemeten 5,8 MB/s. Op een mobiele verbinding met 50 ms zou het ongeveer 1,3 MB/s zijn – HTTP/3 zou mijn gebruikers onderweg dus hebben afgeremd.

Met een buffer van 1 MB liepen downloads via HTTP/3 op 27–31 MB/s, op het niveau van HTTP/2.

De les: een nieuw protocol brengt nieuwe standaardwaarden mee. Eén test met een groot bestand was genoeg om de rem te vinden – daarom hoort die in elke acceptatietest.

🧺 Rem 2: een socketbuffer die overloopt

Daarna de andere richting: een upload van 20 MB. HTTP/3 haalde gemiddeld 7,8 MB/s, HTTP/2 11,9 MB/s – en in die tijd telde de server 284 gedropte UDP-pakketten (RcvbufErrors in /proc/net/snmp).

De reden ligt in het verschil met TCP. Bij TCP regelt de kernel zelf de flow en de buffers. QUIC daarentegen draait in de applicatie, over UDP: elk pakket wacht in de ontvangstbuffer van de socket tot nginx het ophaalt. Standaard geeft Linux een socket hooguit 208 KB – een snelle upload vult dat, en de kernel gooit de volgende pakketten weg. QUIC moet ze opnieuw versturen en remt zichzelf af.

De oplossing heeft twee delen:

  • De kernellimiet verhogen: net.core.rmem_max en net.core.wmem_max naar 7,5 MB – de waarde die QUIC-implementaties aanraden. Dat verhoogt alleen het plafond; alle andere sockets houden hun standaard.
  • De buffers aanvragen: de QUIC-listeners vragen zelf grotere buffers aan met rcvbuf=4m sndbuf=4m. De kernel verdubbelt de waarde intern; ss -m toont dan 8 MB per socket.

Daarna: 0 gedropte pakketten, en uploads via HTTP/3 zaten op het niveau van HTTP/2 – de resterende variatie kwam van mijn eigen uplink.

De les: wie UDP met hoge throughput draait, moet zijn socketbuffers kennen. De kernel telt de gedropte pakketten – je hoeft alleen te kijken.

📊 De metingen

Ik heb vanuit mijn homelab met curl gemeten, 15 verse verbindingen per waarde (mediaan). De blog staat verder weg (ongeveer 42 ms per round trip), de Nextcloud dichterbij (ongeveer 11 ms).

MetingHTTP/2HTTP/3
Blog: verbinding + versleuteling klaar96 ms58 ms
Blog: eerste byte van de voorpagina139 ms104 ms
Blog: volledige voorpagina268 ms227 ms
Nextcloud: verbinding + versleuteling klaar31 ms27 ms
Nextcloud: download 5,7 MB, standaardbuffer34 MB/s5,8 MB/s
Nextcloud: download 5,7 MB, streambuffer 1 MB28 MB/s30 MB/s
Nextcloud: upload 20 MB, socketbuffer 208 KB11,9 MB/s7,8 MB/s
Nextcloud: upload 20 MB, socketbuffer 8 MB15,1 MB/s13,0 MB/s
Nextcloud: upload 100 MB, socketbuffer 8 MB8,7 MB/s7,7 MB/s
Collabora: discovery-request (47 KB)55–72 ms57 ms

Bij 100 MB beperkt mijn eigen uplink beide protocollen even sterk, zonder gedropte pakketten. Grotere downloads konden zonder gebruikersaccount niet getest worden: het grootste publiek bereikbare bestand op de Nextcloud is het scriptbestand van 5,7 MB. Collabora bewerkt documenten via WebSockets, en die blijven over TCP lopen – het enige wat daar te meten valt is de discovery-request.

De winst bij het opzetten van de verbinding is één round trip: TCP en TLS hebben er twee nodig, QUIC doet beide in één. Voor de blog op 42 ms is dat ongeveer 40 ms per nieuwe verbinding; voor de nabije Nextcloud bijna niets. Op mobiele netwerken met 50 tot 100 ms is de winst navenant groter.

De les: HTTP/3 bespaart vooral wachttijd, geen bandbreedte. Hoe verder weg de gebruiker, hoe meer het helpt.

🔧 De overige knoppen

  • quic_gso on: nginx geeft de kernel meerdere QUIC-pakketten tegelijk in plaats van één per aanroep. Dat bespaart CPU bij het verzenden; mijn virtuele netwerkkaarten doen het in software, wat nog steeds helpt. Ingeschakeld.
  • Alt-Svc voor 7 dagen in plaats van 1: terugkerende bezoekers starten langer direct op HTTP/3. Als HTTP/3 later wordt uitgezet, verliest elke browser hooguit één poging – hij valt vanzelf terug op HTTP/2. Ingesteld.
  • quic_bpf: zorgt ervoor dat pakketten van een verbinding na een netwerkwissel bij de juiste nginx-worker aankomen. Daarvoor moet nginx een eBPF-programma laden, wat extra rechten vereist (CAP_BPF, CAP_NET_ADMIN) – juist in de container die naar het internet kijkt en bewust één enkele capability heeft. Niet ingeschakeld: als een migratie mislukt, verbindt de telefoon gewoon opnieuw, met QUIC in één round trip.
  • 0-RTT (ssl_early_data): zou bij terugkerende verbindingen nog een round trip besparen, maar zulke requests kunnen opnieuw worden afgespeeld – logins inbegrepen. Blijft uit.

De les: elke knop heeft een prijs. Wat weinig kost gaat aan; wat de hardening verzwakt blijft uit, ook als het op papier sneller lijkt.

🔤 Een bijvangst: fonts die gzip groter maakte

Dit heeft niet direct met HTTP/3 te maken, maar het viel me op tijdens de performancemetingen. WOFF2-fontbestanden zijn van zichzelf al gecomprimeerd en bevatten dus al ingepakte data. Mijn nginx-configuratie had font/woff2 nog in de lijst met bestandstypen die er nog eens gzip overheen krijgen.

Gemeten op de blog: 18.652 bytes werden 18.680 bytes. De server deed het werk en het bestand groeide met 28 bytes. Dus heb ik de regel verwijderd voor zowel de blog als Nextcloud; tekst, CSS en JavaScript blijven gecomprimeerd. ZIP-bestanden en afbeeldingen stonden nooit op de lijst. Dit is geen merkbare snelheidswinst, alleen een zinloze klus minder.

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

De les: iets comprimeren wat al gecomprimeerd is kost CPU-tijd en levert niets op. Zulke lijsten zijn een tweede blik waard, ook als alles werkt.

🧭 Vanaf het eerste bezoek: het HTTPS-record in DNS

Alt-Svc heeft één zwakte: een browser hoort pas bij het eerste antwoord van HTTP/3. Het allereerste bezoek loopt daarom altijd via HTTP/2. Een eigen DNS-record van het type HTTPS (RFC 9460) lost dat op: het vertelt de browser al tijdens de naamresolutie welke protocollen de server spreekt.

# 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"

De 1 is de prioriteit, de punt betekent “dezelfde naam” en alpn somt de protocollen op in de gewenste volgorde. IP-hints laat ik bewust weg – die zouden bij elke adreswijziging bijgehouden moeten worden. Chrome, Firefox en Safari gebruiken het record. Niet elke DNS-beheerinterface biedt het type aan, dus het loont om dat te checken voordat je je afvraagt waarom het ontbreekt.

Dat is precies mijn geval: het DNS-beheer van mijn provider biedt alleen A-, AAAA-, CNAME-, MX-, NS-, TXT- en SRV-records – een HTTPS-record kan ik daar niet aanmaken. Nabootsen kan ook niet; browsers gebruiken alleen het echte type. Dus bleef de blog bij Alt-Svc: het eerste bezoek liep via HTTP/2, elk volgend bezoek ging zeven dagen lang direct naar HTTP/3. Alleen hiervoor van DNS-provider wisselen zou het me niet waard zijn.

De les: de server kan HTTP/3 alleen aanbieden. Of de browser het al bij het allereerste bezoek gebruikt, bepaalt DNS.

📱 Wat het mijn gebruikers oplevert – en wat niet

  • Browsers op telefoons: de grootste winst – sneller opzetten, geen stilstand van alle requests als één pakket kwijtraakt, en de verbinding overleeft de wissel tussen wifi en mobiele data.
  • Nextcloud-app op iPhone: iOS gebruikt HTTP/3 vanzelf zodra de server het via Alt-Svc aankondigt. De log bevestigt het, zie hieronder.
  • Android-app en desktopclient: volgens de log spreken ze tot nu toe geen HTTP/3, zie hieronder.
  • Collabora en notify_push: draaien via WebSockets. nginx kan geen WebSockets over HTTP/3, dus deze verbindingen blijven op HTTP/1.1 over TCP – dat werkt, alleen zonder het voordeel.

Wat ik van hieruit niet kon meten, is het gedrag op een slecht netwerk. Dat zou de volgende test zijn geweest: met een telefoon in een gebied met zwak bereik, HTTP/3 aan en uit in vergelijking.

De les: wees eerlijk over wie er baat bij heeft. Een protocolupgrade helpt alleen de clients die het spreken.

📈 De eerste cijfers: 13 uur in de log

Een eerste blik in de access logs, van gisteravond tot vanochtend – dus vooral ’s nachts, met navenant weinig verkeer. Alleen browsers en Nextcloud-apps zijn geteld; bots, scripts en mijn eigen tests zijn eruit gefilterd.

ServerRequestsHTTP/3HTTP/2HTTP/1.1
Blog2.03312,3 %67,0 %20,7 %
Grote Nextcloud1.56045,6 %23,5 %30,9 %
Kleine Nextcloud1930 %43,0 %57,0 %
Totaal3.78625,4 %47,8 %26,8 %

Via HTTP/3 was er in die tijd geen enkele serverfout (5xx) en maar één afbreking door een client op 962 requests. De kernel droppte geen UDP-pakketten.

📲 Wie kan HTTP/3 – en wie gebruikt het echt?

De kolom “Kan het” komt uit de documentatie (caniuse), de kolom “In de log” van mijn servers:

ClientKan hetIn de log: aandeel HTTP/3Requests
Nextcloud-app iPhoneja, via het iOS-systeem88,1 %748
Firefox desktopja, vanaf versie 8864,4 %399
Chrome Androidja14,0 %301
Safari macOSja, vanaf versie 164,8 %83
Chrome desktopja, vanaf versie 870 %1.295
Safari iPhoneja, vanaf iOS 160 %312
Edgeja, vanaf versie 870 %111
Nextcloud-app Androidniet in de log0 %210
Nextcloud-desktopclientniet in de log0 % (alles HTTP/1.1)321

De iPhone-app springt eruit: die spreekt HTTP/3 zonder dat iemand iets configureert, omdat iOS het in het systeem regelt. De Android-app en de desktopclient gebruiken het helemaal niet. Op Android ligt dat waarschijnlijk aan de netwerkbibliotheek: OkHttp, wijdverbreid op Android, kan uit zichzelf geen HTTP/3. Of precies dat de app tegenhoudt, heb ik niet in de broncode gecontroleerd.

De 0 % voor Chrome desktop en Safari iPhone moet je met voorzichtigheid lezen. Veel requests met deze identificaties komen van bots die zich als browser voordoen – een echte Chrome spreekt praktisch nooit HTTP/1.1 over HTTPS. Bovendien hoort een browser pas bij het eerste antwoord van HTTP/3 en blijft hij daarna op de open verbinding. Wie maar één artikel leest, blijft dus op HTTP/2. De mobiele versie laat zien dat Chrome in principe werkt.

De les: ondersteuning op papier zegt weinig. Alleen de log laat zien wie een protocol echt spreekt – en bij mij is dat vooral de iPhone-app.

📅 Stand van zaken en vooruitblik

Op 3 november draaide HTTP/3 op alle drie de servers: de blog en beide Nextcloud-instanties. De tweede Nextcloud nam ik af met dezelfde checks als de eerste, en de drift-check meldt overal changed=0 – de servers komen exact overeen met de code in de publieke repository.

Het plan was om na een week naar drie dingen te kijken:

  • Gebruik: welk aandeel van de requests in de access log komt binnen via HTTP/3.0 – uitgesplitst naar browsers, Nextcloud-apps en sync-clients?
  • Fouten: zijn er via HTTP/3 meer foutantwoorden of afgebroken uploads dan via HTTP/2?
  • Praktijk: hoe gedraagt de Nextcloud zich op een telefoon met zwak bereik, met en zonder HTTP/3?

Zover kwam het niet: een dag later zette ik HTTP/3 weer uit, dus de evaluatie en de aparte post vervallen. De reden staat in de update aan het eind. Zoals gepland kostte de terugweg één schakelaar en één playbook-run.

🎯 De lessen

  1. Controleer eerst wat de binary kan – “geen optie” betekent niet “geen module”.
  2. Test met grote bestanden, in beide richtingen – kleine requests verbergen elke throughput-rem.
  3. UDP-buffers horen bij QUIC – RcvbufErrors laten zien of de kernel pakketten dropt.
  4. Test met echte logregels – een zelfgemaakt voorbeeld test alleen het voorbeeld.
  5. Zet het aan omdat het helpt – gemeten, niet aangenomen, en met een schakelaar die terug kan.

🔄 Update, 4 november 2026: HTTP/3 gaat weer uit

Kort gezegd: een dag na deze post vond ik een echte bug. HTTP/3-downloads op de grote Nextcloud bleven in ongeveer 11 % van de runs hangen. De oorzaak is gevonden en met een tegentest onderbouwd. Daarom heb ik HTTP/3 weer uitgezet, op beide Nextclouds en dezelfde avond ook op de blog. Stabiliteit en betrouwbaarheid zijn me belangrijker dan een nieuw protocol waarvan ik het voordeel tot nu toe niet heb kunnen meten.

Hoe het zich liet zien. Eigenlijk wilde ik testen of een nog grotere streambuffer helpt. Dus herhaalde ik de meting met veel meer runs, en ineens stonden losse runs op 0 MB/s. curl meldde HTTP/3 stream 0 reset by server, en de serverlog toonde een afbreking na 60 seconden. Via HTTP/2 gebeurde dit geen enkele keer. De dag ervoor had ik het niet gemerkt: ik had maar 8 downloadruns gedaan, en de trigger verscheen waarschijnlijk pas daarna.

Het verkeerde spoor. De hangers zaten opvallend vaak op precies 523.559 bytes. Met waarschijnlijk 729 bytes protocol erbovenop is dat precies 512 KiB, het initiële venster van de QUIC-stack van OpenSSL, die mijn curl gebruikt. In de capture stopte de server na 0,37 seconde met verzenden en vielen beide kanten stil. Eerst hield ik dit voor een probleem van de testclient en noteerde het ook zo. Dat was fout. De tegentest met nog twee QUIC-implementaties liet dit zien:

ClientGrote NextcloudKleine Nextcloud
curl met OpenSSL15 van 117 hangen0 van 32
curl met quiche3 van 400 van 40
aioquic3 van 400 van 25

Drie verschillende clients hangen dus op maar één van de twee servers. Daarmee lag het bij de server, niet bij de client.

De oorzaak. Op de grote Nextcloud draaide een oude nginx-worker die er niet meer had moeten zijn:

$ ps -eo args | grep 'shutting down'
nginx: worker process is shutting down

Deze toestand is op zich normaal. Bij een reload van nginx starten nieuwe workers en maken de oude hun lopende verbindingen af. Hier hoorde de reload bij een normale rollout. Maar de oude worker hield een websocket van een client naar notify_push vast, de pushdienst van Nextcloud. Zo’n verbinding eindigt niet vanzelf, en ik had geen tijdslimiet ingesteld. De worker zou dus waarschijnlijk eindeloos zijn blijven draaien.

Bij TCP kan dat geen kwaad, want elke verbinding heeft een eigen socket. Bij QUIC delen alle verbindingen UDP-sockets. De oude worker hield die sockets open en kon blijkbaar ook pakketten opvangen die voor de nieuwe workers bedoeld waren. Dat past bij de cijfers: bij 8 workers zou het ongeveer 1 op 8 verbindingen moeten treffen, en ik mat 21 van 197, ongeveer 11 %. Het verloop leidde ik eerst af uit de metingen. Een nginx-ontwikkelaar beschrijft hetzelfde mechanisme in Issue #1399 en heeft het gereproduceerd.

Het bewijs. Ik beëindigde alleen deze ene oude worker en herhaalde alles. Resultaat: 0 van 200 runs hangen, over alle drie de clients, tegenover 21 van 197 eerder. De kleine Nextcloud en de blog hadden zo’n worker niet en vertoonden ook geen hangers; op de blog was het 0 van 120 requests via HTTP/3.

Waar zit de fout? HTTP/3 is niet fundamenteel onverenigbaar met mijn setup; zonder oude worker liep alles netjes. Het probleem is een bekende zwakte van nginx bij reloads, beschreven in issue #425. De issue is in oktober gesloten, en volgens de changelog handelt de nginx 1.31.7 die ik gebruik reloads met QUIC af, maar alleen met quic_bpf. Dat had ik bewust weggelaten. Mijn setup draagt eraan bij: de F5-controller heeft geen eigen HTTP/3-optie, ik heb het zelf via snippets ingeschakeld, en notify_push houdt oude workers in leven.

Wat ik heb onderzocht en verworpen:

  • Een nieuwere Ingress Controller: ik draai al de nieuwste versie, 5.7.0. Er is geen update.
  • quic_bpf: de eigen oplossing van nginx, maar de securitykant bevalt me op dit moment niet. De ingress-container draait zonder root en mag alleen lage poorten zoals 443 binden. Met quic_bpf zou hij ook CAP_BPF en CAP_NET_ADMIN nodig hebben, omdat nginx daarvoor een eBPF-programma in de kernel laadt. Deze container hangt direct aan het internet en draait in het hostnetwerk. Wie erin inbreekt, zou met CAP_NET_ADMIN ook de netwerkinstellingen van de server kunnen wijzigen. Voor een voordeel dat ik tot nu toe niet heb kunnen meten, is dat voor mij een te slechte ruil.
  • worker-shutdown-timeout: beëindigt oude workers na een vaste tijd. Tot dan blijft de bug, en daarna breekt het ook lopende grote downloads en uploads af. Op een Nextcloud is dat een slechte ruil. Voor de blog heb ik het getest, daarover hieronder meer.
  • Kernel of nftables: de kernel kent geen “oude” workers, en beide workers delen dezelfde socket. Geen firewallregel kan pakketten tussen hen verdelen. Een script dat UDP 443 een tijdje blokkeert, zou alleen nog een onderdeel zijn dat kan falen.

Kan een aanvaller dit misbruiken? Ik zie er geen bruikbare aanval in. QUIC is versleuteld, en ik heb geen aanwijzing dat er data zichtbaar wordt. Het resultaat zijn hangende verbindingen, dus puur een beschikbaarheidsprobleem. Reloads kunnen ook niet van buitenaf worden uitgelokt; ze gebeuren alleen tijdens mijn rollouts en geplande jobs. Dat is geen garantie, maar met HTTP/3 uit is deze weg sowieso dicht. Googlebot was trouwens niet getroffen: de afgelopen 24 uur kwam die alleen via HTTP/1.1.

Wat ik niet weet: hoeveel echte gebruikers op die ene dag getroffen waren. De log toont nauwelijks afbrekingen via HTTP/3, maar heeft geen responstijden. Een hanger die later toch nog afrondde, zou daar onzichtbaar zijn. Dit “nauwelijks” is dus ook geen sein veilig. Ook open is hoe snel clients terugvallen die HTTP/3 nog onthouden hebben: mijn browser opende de Nextcloud normaal, terwijl curl met een onthouden entry 30 seconden bleef hangen. Het antwoord voor de iOS-app is nu redelijk duidelijk. Ik gebruik die zelf niet en kan alleen tellen: binnen 20 uur na het uitzetten waren 7 iOS-apparaten teruggekomen, zonder ingreep, en de log die ik bekeek toonde geen afbrekingen of serverfouten. Geen van de apparaten die in de drie dagen voor het uitzetten actief waren, is sindsdien verdwenen. Nog zeven apparaten die al meer dan drie dagen voor het uitzetten stil waren, hebben zich nog niet weer gemeld; of ze gewoon zelden gebruikt worden, kan de log niet laten zien. Alt-Svc: clear was tot nu toe niet nodig. Ik houd het tot 12 november in de gaten.

De stand na de rollout:

# All hosts
ingress_http3_enabled: false
  • Beide Nextclouds: HTTP/3 uit. Werkbestanden en sync hangen ervan af, en precies daar zitten de lange verbindingen.
  • Blog: HTTP/3 staat nu ook hier uit. Eerst wilde ik het houden met een limiet van 5 minuten voor oude workers, omdat de transfers daar kort zijn. De test ging goed: met een bewust aangemaakte oude worker bleven 8 van 55 requests via HTTP/3 hangen. Na ongeveer 5 minuten was hij weg, en daarna hingen er 0 van 110. Een bewust trage upload werd zoals verwacht afgebroken. Toch overtuigde het me niet helemaal: de bug blijft tot de limiet afloopt, en in PR #503 meldt een andere beheerder, op een oudere versie, een oude worker die door zijn limiet niet werd beëindigd.
  • Hoe het verder gaat: ik heb in nginx Issue #1937 gevraagd of er een oplossing zonder de extra rechten van quic_bpf gepland is, en wacht op het antwoord. In de wekelijkse updaterapporten houd ik ook in de gaten of F5 HTTP/3 officieel gaat ondersteunen of nginx reloads oplost zonder quic_bpf. De schakelaar blijft: ik kan HTTP/3 op elk moment weer aanzetten.

Wat ik hieruit meeneem:

  1. Acht runs bewijzen niets. Een bug die elke negende run treft, glipt er makkelijk doorheen. Meet betrouwbaarheid met veel runs, niet alleen snelheid.
  2. Controleer de eerste verklaring. De 512 KiB pasten verbluffend goed en leidden toch de verkeerde kant op. Pas een tweede en derde client lieten dat zien.
  3. Meet opnieuw na elke reload. De bug verscheen niet bij het inschakelen, maar tijdens een latere, volkomen normale rollout.
  4. Een schakelaar is goud waard. Omdat HTTP/3 aan één schakelaar per server hangt, is de terugtocht klein en altijd terug te draaien.
  5. Nieuw betekent niet beter. Zonder meetbaar voordeel weegt betrouwbaarheid zwaarder.
Sommige teksten en afbeeldingen op deze site zijn met hulp van AI gemaakt of door AI gegenereerd. Details