HTTP/3 para o meu blog e o Nextcloud: um interruptor, dois freios escondidos e o que as medições mostram
HTTP/3 no meu ingress Kubernetes: como funciona sem uma opção oficial, o que o freou no início – e por que o desliguei de novo após um dia por causa de conexões travadas.

🌐 Também em: English · Deutsch · Français · Español · Italiano · Nederlands · Polski
Atualização de 6 de novembro de 2026: o HTTP/3 voltou a funcionar aqui, com nginx mainline e quic_bpf. A história está no post sobre a migração.
Atualização, 4 de novembro de 2026: o HTTP/3 está desligado de novo em todos os meus servidores. O motivo está no fim deste post.
Muitos usuários das minhas instâncias Nextcloud acessam pelo celular. É exatamente para isso que o HTTP/3 foi criado: ele roda sobre QUIC em vez de TCP, precisa de uma viagem de ida e volta a menos para estabelecer a conexão, lida melhor com perda de pacotes e consegue manter a conexão viva quando o celular troca do Wi-Fi para os dados móveis. Meu objetivo, porém, não era “ter HTTP/3”, e sim: HTTP/3 só se ajudar de forma mensurável – mais throughput ou uma conexão mais estável em uma rede ruim.
Este post descreve como eu o liguei, como provo que ele realmente funciona – e os dois freios que no início deixaram o HTTP/3 claramente mais lento que o HTTP/2.
Índice
🧒 Para quem não é de TI: o que é HTTP – e por que de repente UDP?
HTTP é a língua entre o navegador e o servidor web. O navegador pede “me dá esta página”, o servidor a envia. Cada imagem, cada texto e cada arquivo no Nextcloud viaja por esse caminho. Mas o HTTP só define o que é dito. Como os dados atravessam a rede fica a cargo de uma camada abaixo – e existem dois métodos:
| TCP | UDP | |
|---|---|---|
| Comparação | Carta registrada: o recebimento é confirmado, o que se perde é reenviado | Cartão-postal: envia e segue em frente, sem confirmação |
| Ordem | sempre chega na ordem certa | sem garantia |
| Estabelecimento da conexão | primeiro um handshake, que leva tempo | nenhum, começa na hora |
| Em caso de perda de pacotes | tudo o que vem atrás espera pela peça que falta | o próprio UDP nem percebe |
| Típico para | sites (até agora), e-mail, arquivos | DNS, videochamadas, jogos |
HTTP/1.1 e HTTP/2 rodam sobre TCP. Só o HTTP/3 roda sobre UDP – mais precisamente sobre QUIC, que fica em cima do UDP e cuida ele mesmo da confiabilidade: com QUIC também nada se perde, ele só reenvia de forma mais inteligente.
Por que tanto esforço? Se um único pacote se perde com HTTP/2, todos os arquivos da página esperam por ele no TCP. Com HTTP/3, só o arquivo afetado espera. Uma conexão TCP também está presa ao endereço IP: quando o celular passa do Wi-Fi para os dados móveis, ela cai. O QUIC tem um ID de conexão próprio e consegue continuar. São exatamente as situações de um celular em movimento.
A lição: HTTP/3 não é uma nova web, e sim o mesmo conteúdo em um transporte que lida melhor com redes ruins.
🔌 O controller não consegue – o nginx dele consegue
Meu ingress é o NGINX Ingress Controller da F5. Ele não tem nenhuma opção para HTTP/3: nenhum interruptor, nenhuma chave de ConfigMap, nada nas release notes. Mas uma olhada dentro do pod em execução mostra que o nginx 1.31.7 incluído foi compilado com --with-http_v3_module, junto com o OpenSSL 3.5, a primeira versão do OpenSSL que faz QUIC do lado do servidor. E como o controller roda com hostNetwork, o nginx pode abrir a porta UDP 443 diretamente.
Então vai pelos snippets que eu já uso:
# 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;
reuseportsó uma vez por endereço: o nginx permite essa opção em uma única linhalistenpor endereço e porta. Por isso ela fica só no bloco server do site principal, e todos os outros hosts compartilham esses sockets.- Alt-Svc só via HTTPS: esse header avisa os navegadores de que existe HTTP/3. O
mapo define só para HTTPS; na porta 80 o valor fica vazio, e aí o nginx não envia header nenhum. - Alt-Svc ao lado dos outros headers: o nginx não herda
add_headerquando uma location define seus próprios headers. Meus headers de segurança ficam nos location snippets – então o Alt-Svc também tem que ir para lá. - Firewall: UDP 443 de entrada para IPv4 e IPv6. Na saída não precisa de regra; as respostas são “established” para o conntrack.
Tudo depende de um interruptor por host (ingress_http3_enabled), desligado por padrão. Liguei primeiro o blog, depois o Nextcloud menor. Antes da execução real, conferi as novas linhas com nginx -t contra uma cópia da configuração dentro do pod.
A lição: “não suportado” às vezes só significa “não tem interruptor”. nginx -V mostra o que o binário realmente sabe fazer.
🤔 Por que achei por tanto tempo que HTTP/3 era impossível
Eu já tinha verificado isso uma vez, em agosto – com o resultado “não é possível”. Era também o que dizia desde então um comentário no meu template de firewall. Na época verifiquei duas coisas: o controller tem uma opção para HTTP/3? Não. O servidor responde via HTTP/3? Não, claro que não – não havia listener QUIC.
O que eu não tinha verificado: se o nginx do controller contém o módulo. A conclusão “sem opção, portanto sem suporte” foi rápida demais. Se a imagem da época já tinha o módulo não dá mais para rastrear hoje – a atual tem, junto com uma versão do OpenSSL que faz QUIC do lado do servidor. Só a pergunta “o que o binário sabe fazer?” em vez de “o que a configuração oferece?” levou à outra resposta.
A lição: um “não é possível” merece uma data e um motivo – e uma segunda verificação quando o software mudar.
✅ Como ver que o HTTP/3 realmente está rodando
Uma página que carrega não diz nada sobre o protocolo. Fiz estas verificações depois de cada ativação:
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 forçado com
curl --http3-onlyem todos os caminhos importantes: página inicial, login, ostatus.phpdo Nextcloud, a API OCS, WebDAV, Collabora – em todos, a resposta esperada via h3. - Mesmo conteúdo: um arquivo JavaScript grande carregado via HTTP/2 e via HTTP/3 – checksum SHA-256 idêntico. Os headers de resposta também são os mesmos.
- Lado do servidor:
ss -ulnpmostra um socket UDP por worker do nginx na porta 443, IPv4 e IPv6; o access log mostra requisições comHTTP/3.0. - De fora: o http3check.net confirma QUIC versão 1 e HTTP/3, testado via IPv6 – que eu nem consigo testar de casa.
- Segurança inalterada: os filtros do fail2ban casam linhas de login com
HTTP/3.0do mesmo jeito que comHTTP/2.0. O 0-RTT early data continua desligado, então ninguém consegue repetir um formulário de login.
Uma pequena armadilha: meu primeiro teste do fail2ban falhou – com uma linha de log feita à mão no formato errado. Com uma linha real do log, trocando só o protocolo, o filtro casou na hora.
A lição: uma prova precisa de vários ângulos – cliente, servidor, um terceiro de fora e as suas próprias ferramentas de segurança.
🐢 Freio 1: 64 KB por viagem de ida e volta
Requisições pequenas ficaram tão rápidas ou mais rápidas via HTTP/3 logo de cara. Então veio o teste com um arquivo grande: 5,7 MB levaram 0,18 segundo via HTTP/2 e 0,99 segundo via HTTP/3 – mais de cinco vezes mais.
O cliente quase não usava CPU; ele estava esperando. A conta levou à causa: por padrão o nginx bufferiza só 64 KB por stream QUIC (http3_stream_buffer_size). Um stream não pode ter mais do que isso em trânsito. 64 KB por viagem de ida e volta a 11 ms dão exatamente os 5,8 MB/s medidos. Em uma conexão móvel com 50 ms seriam cerca de 1,3 MB/s – ou seja, o HTTP/3 teria freado meus usuários em movimento.
Com um buffer de 1 MB, os downloads via HTTP/3 ficaram em 27–31 MB/s, no nível do HTTP/2.
A lição: um protocolo novo traz novos padrões. Um único teste com um arquivo grande bastou para achar o freio – é por isso que ele faz parte de todo teste de aceitação.
🧺 Freio 2: um buffer de socket que transborda
Depois, a outra direção: um upload de 20 MB. O HTTP/3 ficou em média em 7,8 MB/s, o HTTP/2 em 11,9 MB/s – e durante esse tempo o servidor contou 284 pacotes UDP descartados (RcvbufErrors em /proc/net/snmp).
O motivo está na diferença em relação ao TCP. Com TCP, o próprio kernel cuida do fluxo e dos buffers. O QUIC, por outro lado, roda na aplicação, sobre UDP: cada pacote espera no buffer de recepção do socket até o nginx pegá-lo. Por padrão o Linux dá a um socket no máximo 208 KB – um upload rápido enche isso, e o kernel joga fora os pacotes seguintes. O QUIC tem que reenviá-los e se freia sozinho.
A correção tem duas partes:
- Aumentar o limite do kernel:
net.core.rmem_maxenet.core.wmem_maxpara 7,5 MB – o valor que as implementações de QUIC recomendam. Isso só aumenta o teto; todos os outros sockets mantêm seu padrão. - Pedir os buffers: os listeners QUIC pedem eles mesmos buffers maiores com
rcvbuf=4m sndbuf=4m. O kernel dobra o valor internamente;ss -mmostra então 8 MB por socket.
Depois: 0 pacotes descartados, e os uploads via HTTP/3 ficaram no nível do HTTP/2 – a variação restante vinha do meu próprio uplink.
A lição: se você roda UDP com throughput alto, precisa conhecer seus buffers de socket. O kernel conta os pacotes descartados – basta olhar.
📊 As medições
Medi a partir do meu homelab com curl, 15 conexões novas por valor (mediana). O blog fica mais longe (cerca de 42 ms por viagem de ida e volta), o Nextcloud mais perto (cerca de 11 ms).
| Medição | HTTP/2 | HTTP/3 |
|---|---|---|
| Blog: conexão + criptografia prontas | 96 ms | 58 ms |
| Blog: primeiro byte da página inicial | 139 ms | 104 ms |
| Blog: página inicial completa | 268 ms | 227 ms |
| Nextcloud: conexão + criptografia prontas | 31 ms | 27 ms |
| Nextcloud: download de 5,7 MB, buffer padrão | 34 MB/s | 5,8 MB/s |
| Nextcloud: download de 5,7 MB, stream buffer de 1 MB | 28 MB/s | 30 MB/s |
| Nextcloud: upload de 20 MB, socket buffer de 208 KB | 11,9 MB/s | 7,8 MB/s |
| Nextcloud: upload de 20 MB, socket buffer de 8 MB | 15,1 MB/s | 13,0 MB/s |
| Nextcloud: upload de 100 MB, socket buffer de 8 MB | 8,7 MB/s | 7,7 MB/s |
| Collabora: requisição de discovery (47 KB) | 55–72 ms | 57 ms |
Com 100 MB, meu próprio uplink limita os dois protocolos por igual, sem pacotes descartados. Downloads maiores não puderam ser testados sem uma conta de usuário: o maior arquivo publicamente acessível no Nextcloud é o arquivo de script de 5,7 MB. O Collabora edita documentos via WebSockets, que continuam rodando sobre TCP – a única coisa para medir ali é a requisição de discovery.
O ganho no estabelecimento da conexão é uma viagem de ida e volta: TCP e TLS precisam de duas, o QUIC faz as duas coisas em uma. Para o blog, a 42 ms, isso dá cerca de 40 ms por conexão nova; para o Nextcloud próximo, quase nada. Em redes móveis com 50 a 100 ms, o ganho é proporcionalmente maior.
A lição: o HTTP/3 economiza principalmente tempo de espera, não largura de banda. Quanto mais longe o usuário, mais ele ajuda.
🔧 Os ajustes restantes
quic_gso on: o nginx entrega ao kernel vários pacotes QUIC de uma vez em vez de um por chamada. Isso economiza CPU no envio; minhas placas de rede virtuais fazem isso em software, o que ainda ajuda. Ligado.- Alt-Svc por 7 dias em vez de 1: visitantes que voltam começam direto em HTTP/3 por mais tempo. Se o HTTP/3 for desligado depois, cada navegador perde no máximo uma tentativa – ele volta sozinho para o HTTP/2. Configurado.
quic_bpf: garante que os pacotes de uma conexão cheguem ao worker certo do nginx depois de uma troca de rede. Para isso o nginx tem que carregar um programa eBPF, o que exige privilégios extras (CAP_BPF,CAP_NET_ADMIN) – justamente no container que está exposto à internet e que, de propósito, tem uma única capability. Não ligado: se uma migração falhar, o celular simplesmente reconecta, com QUIC em uma viagem de ida e volta.- 0-RTT (
ssl_early_data): economizaria mais uma viagem de ida e volta em conexões de retorno, mas essas requisições podem ser repetidas – logins incluídos. Continua desligado.
A lição: cada ajuste tem um preço. O que custa pouco é ligado; o que enfraquece o hardening fica desligado, mesmo que pareça mais rápido no papel.
🔤 Uma descoberta paralela: fontes que o gzip deixou maiores
Isso não tem a ver diretamente com HTTP/3, mas percebi durante as medições de desempenho. Arquivos de fonte WOFF2 são comprimidos por natureza, então já contêm dados compactados. Minha configuração do nginx ainda tinha font/woff2 na lista de tipos de arquivo que recebem gzip por cima.
Medido no blog: 18.652 bytes viraram 18.680 bytes. O servidor fez o trabalho e o arquivo cresceu 28 bytes. Então removi a entrada tanto no blog quanto no Nextcloud; texto, CSS e JavaScript continuam comprimidos. Arquivos ZIP e imagens nunca estiveram na lista. Isso não é um ganho de velocidade perceptível, só um trabalho inútil a menos.
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
A lição: comprimir algo que já está comprimido custa tempo de CPU e não ganha nada. Listas assim merecem uma segunda olhada, mesmo quando tudo funciona.
🧭 Desde a primeira visita: o registro HTTPS no DNS
O Alt-Svc tem um defeito: o navegador só descobre o HTTP/3 pela primeira resposta. Por isso a primeiríssima visita sempre roda via HTTP/2. Um registro DNS próprio do tipo HTTPS (RFC 9460) resolve isso: ele informa ao navegador, já na resolução do nome, quais protocolos o servidor fala.
# 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"
O 1 é a prioridade, o ponto significa “o mesmo nome” e alpn lista os protocolos na ordem de preferência. Deixo de fora, de propósito, os IP hints – eles teriam que ser mantidos a cada mudança de endereço. Chrome, Firefox e Safari usam o registro. Nem toda interface de gerenciamento de DNS oferece esse tipo, então vale conferir antes de ficar se perguntando por que ele não aparece.
Esse é exatamente o meu caso: o gerenciamento de DNS do meu provedor oferece só registros A, AAAA, CNAME, MX, NS, TXT e SRV – não consigo criar um registro HTTPS ali. Também não dá para emulá-lo; os navegadores só usam o tipo real. Então o blog ficou com o Alt-Svc: a primeira visita rodava via HTTP/2, e todas as seguintes iam direto para HTTP/3 por sete dias. Trocar de provedor de DNS só por isso não valeria a pena para mim.
A lição: o servidor só pode oferecer HTTP/3. Se o navegador o usa já na primeiríssima visita depende do DNS.
📱 O que isso traz para os meus usuários – e o que não traz
- Navegadores no celular: o maior ganho – estabelecimento mais rápido, nenhuma parada de todas as requisições quando um pacote se perde, e a conexão sobrevive à troca entre Wi-Fi e dados móveis.
- App do Nextcloud no iPhone: o iOS usa HTTP/3 por conta própria assim que o servidor o anuncia via Alt-Svc. O log confirma, veja abaixo.
- App Android e cliente desktop: segundo o log, até agora não falam HTTP/3, veja abaixo.
- Collabora e notify_push: rodam via WebSockets. O nginx não faz WebSockets sobre HTTP/3, então essas conexões ficam em HTTP/1.1 sobre TCP – funciona, só que sem o benefício.
O que eu não consegui medir daqui é o comportamento em uma rede ruim. Esse teria sido o próximo teste: com um celular em uma área com sinal fraco, HTTP/3 ligado e desligado em comparação.
A lição: seja honesto sobre quem se beneficia. Um upgrade de protocolo só ajuda os clientes que o falam.
📈 Os primeiros números: 13 horas no log
Uma primeira olhada nos access logs, de ontem à noite até hoje de manhã – portanto principalmente durante a madrugada, com pouco tráfego correspondente. Só navegadores e apps do Nextcloud são contados; bots, scripts e meus próprios testes ficam de fora.
| Servidor | Requisições | 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 pequeno | 193 | 0 % | 43,0 % | 57,0 % |
| Total | 3.786 | 25,4 % | 47,8 % | 26,8 % |
Via HTTP/3 não houve um único erro de servidor (5xx) nesse período e só um aborto do cliente em 962 requisições. O kernel não descartou nenhum pacote UDP.
📲 Quem sabe fazer HTTP/3 – e quem realmente usa?
A coluna “Sabe fazer” vem da documentação (caniuse), a coluna “No log” vem dos meus servidores:
| Cliente | Sabe fazer | No log: parcela de HTTP/3 | Requisições |
|---|---|---|---|
| App do Nextcloud iPhone | sim, via o sistema iOS | 88,1 % | 748 |
| Firefox desktop | sim, a partir da versão 88 | 64,4 % | 399 |
| Chrome Android | sim | 14,0 % | 301 |
| Safari macOS | sim, a partir da versão 16 | 4,8 % | 83 |
| Chrome desktop | sim, a partir da versão 87 | 0 % | 1.295 |
| Safari iPhone | sim, a partir do iOS 16 | 0 % | 312 |
| Edge | sim, a partir da versão 87 | 0 % | 111 |
| App do Nextcloud Android | não aparece no log | 0 % | 210 |
| Cliente desktop do Nextcloud | não aparece no log | 0 % (tudo HTTP/1.1) | 321 |
O app de iPhone se destaca: ele fala HTTP/3 sem ninguém configurar nada, porque o iOS cuida disso no sistema. O app Android e o cliente desktop não o usam de jeito nenhum. No Android isso provavelmente se deve à biblioteca de rede: o OkHttp, muito difundido no Android, não sabe fazer HTTP/3 sozinho. Se é exatamente isso que impede o app, não verifiquei no código-fonte dele.
Os 0 % do Chrome desktop e do Safari iPhone devem ser lidos com cautela. Muitas requisições com esses identificadores vêm de bots se passando por navegadores – um Chrome de verdade praticamente nunca fala HTTP/1.1 sobre HTTPS. Além disso, um navegador só descobre o HTTP/3 pela primeira resposta e depois fica na conexão já aberta. Então quem lê só um artigo fica no HTTP/2. A versão mobile mostra que o Chrome funciona em princípio.
A lição: suporte no papel diz pouco. Só o log mostra quem realmente fala um protocolo – e, no meu caso, é sobretudo o app de iPhone.
📅 Situação e perspectivas
Em 3 de novembro, o HTTP/3 rodava em todos os três servidores: o blog e as duas instâncias Nextcloud. Aceitei o segundo Nextcloud com as mesmas verificações do primeiro, e o drift check informa changed=0 em todos – os servidores correspondem exatamente ao código do repositório público.
O plano era olhar três coisas depois de uma semana:
- Uso: qual parcela das requisições no access log chega via
HTTP/3.0– separada por navegadores, apps do Nextcloud e clientes de sincronização? - Erros: há mais respostas de erro ou uploads abortados via HTTP/3 do que via HTTP/2?
- Prática: como o Nextcloud se comporta em um celular com sinal fraco, com e sem HTTP/3?
Não chegou a tanto: um dia depois desliguei o HTTP/3 de novo, então a avaliação e o post separado caem. O motivo está na atualização no fim. Como planejado, voltar atrás custou um interruptor e uma execução do playbook.
🎯 As lições
- Primeiro verifique o que o binário sabe fazer – “sem opção” não significa “sem módulo”.
- Teste com arquivos grandes, nas duas direções – requisições pequenas escondem todo freio de throughput.
- Buffers UDP fazem parte do QUIC –
RcvbufErrorsmostram se o kernel está descartando pacotes. - Teste com linhas de log reais – um exemplo feito à mão só testa o exemplo.
- Ligue porque ajuda – medido, não presumido, e com um interruptor que pode ser revertido.
🔄 Atualização, 4 de novembro de 2026: o HTTP/3 é desligado de novo
Em resumo: um dia depois deste post encontrei um bug real. Downloads via HTTP/3 no Nextcloud grande travavam em cerca de 11 % das execuções. A causa foi encontrada e confirmada por um contrateste. Por isso desliguei o HTTP/3 de novo, nos dois Nextclouds e, na mesma noite, também no blog. Estabilidade e confiabilidade importam mais para mim do que um protocolo novo cujo benefício eu não consegui medir até agora.
Como apareceu. Na verdade eu queria testar se um stream buffer ainda maior ajuda. Então repeti a medição com muito mais execuções, e de repente algumas execuções ficavam em 0 MB/s. O curl informava HTTP/3 stream 0 reset by server, e o log do servidor mostrava um aborto depois de 60 segundos. Via HTTP/2 isso não aconteceu nem uma vez. Eu não tinha percebido no dia anterior: tinha feito só 8 execuções de download, e o gatilho provavelmente só apareceu depois.
A pista falsa. Os travamentos aconteciam com frequência marcante em exatamente 523.559 bytes. Com provavelmente 729 bytes de protocolo por cima, isso dá exatamente 512 KiB, a janela inicial da pilha QUIC do OpenSSL, que o meu curl usa. Na captura, o servidor parava de enviar depois de 0,37 segundo e os dois lados ficavam em silêncio. No início achei que fosse um problema do cliente de teste e até anotei assim. Estava errado. O contrateste com mais duas implementações de QUIC mostrou isto:
| Cliente | Nextcloud grande | Nextcloud pequeno |
|---|---|---|
| curl com OpenSSL | 15 de 117 travam | 0 de 32 |
| curl com quiche | 3 de 40 | 0 de 40 |
| aioquic | 3 de 40 | 0 de 25 |
Ou seja, três clientes diferentes travam em só um dos dois servidores. Isso colocava a culpa no servidor, não no cliente.
A causa. No Nextcloud grande havia um worker antigo do nginx rodando que não deveria mais estar lá:
$ ps -eo args | grep 'shutting down'
nginx: worker process is shutting down
Esse estado é normal a princípio. Quando o nginx recarrega, novos workers começam e os antigos terminam suas conexões em andamento. Aqui o reload fazia parte de um rollout normal. Mas o worker antigo segurava um websocket de um cliente para o notify_push, o serviço de push do Nextcloud. Uma conexão assim não termina sozinha, e eu não tinha definido nenhum limite de tempo. Então o worker provavelmente teria continuado rodando indefinidamente.
Com TCP isso não faz mal, porque cada conexão tem seu próprio socket. Com QUIC, todas as conexões compartilham sockets UDP. O worker antigo mantinha esses sockets abertos e aparentemente também podia capturar pacotes destinados aos novos workers. Isso bate com os números: com 8 workers deveria atingir cerca de 1 em cada 8 conexões, e eu medi 21 de 197, cerca de 11 %. Primeiro deduzi a sequência a partir das medições. Um desenvolvedor do nginx descreve o mesmo mecanismo na Issue #1399 e o reproduziu.
A prova. Encerrei só esse worker antigo e repeti tudo. Resultado: 0 de 200 execuções travam, nos três clientes, contra 21 de 197 antes. O Nextcloud pequeno e o blog não tinham um worker assim e também não mostraram travamentos; no blog foram 0 de 120 requisições via HTTP/3.
Onde está a falha? O HTTP/3 não é fundamentalmente incompatível com o meu setup; sem um worker antigo tudo rodou limpo. O problema é uma fraqueza conhecida do nginx durante reloads, descrita na issue #425. A issue foi fechada em outubro e, segundo o changelog, o nginx 1.31.7 que uso lida com reloads com QUIC, mas só com quic_bpf. Eu tinha deixado isso de fora de propósito. Meu setup contribui: o controller da F5 não tem uma opção própria de HTTP/3, eu o ativei por conta própria via snippets, e o notify_push mantém workers antigos vivos.
O que verifiquei e descartei:
- Um Ingress Controller mais novo: já uso a versão mais nova, 5.7.0. Não há atualização.
quic_bpf: a solução do próprio nginx, mas o lado da segurança não me agrada no momento. O container do ingress roda sem root e só pode fazer bind em portas baixas como a 443. Comquic_bpfele precisaria também deCAP_BPFeCAP_NET_ADMIN, porque o nginx carrega um programa eBPF no kernel para isso. Esse container fica exposto diretamente à internet e roda na rede do host. Quem invadi-lo poderia usarCAP_NET_ADMINpara mudar também as configurações de rede do servidor. Por um benefício que não consegui medir até agora, é uma troca ruim demais para mim.worker-shutdown-timeout: encerra workers antigos depois de um tempo fixo. Até lá o bug continua, e depois disso ele também corta downloads e uploads grandes em andamento. Em um Nextcloud isso é uma troca ruim. Testei para o blog, mais sobre isso abaixo.- Kernel ou nftables: o kernel não conhece workers “antigos”, e os dois workers compartilham o mesmo socket. Nenhuma regra de firewall consegue distribuir pacotes entre eles. Um script que bloqueie UDP 443 por um tempo seria só mais uma peça que pode falhar.
Um atacante pode explorar isso? Não vejo um ataque útil aí. O QUIC é criptografado, e não tenho nenhum indício de que algum dado fique visível. O resultado são conexões travadas, ou seja, puramente um problema de disponibilidade. Reloads também não podem ser disparados de fora; eles só acontecem durante meus rollouts e jobs agendados. Isso não é garantia, mas com o HTTP/3 desligado esse caminho está fechado de qualquer forma. O Googlebot, aliás, não foi afetado: nas últimas 24 horas ele só veio via HTTP/1.1.
O que eu não sei: quantos usuários reais foram afetados naquele único dia. O log mostra quase nenhum aborto via HTTP/3, mas não tem tempos de resposta. Um travamento que ainda terminou depois seria invisível ali. Então esse “quase nenhum” também não é sinal verde. Também está em aberto com que rapidez voltam os clientes que ainda se lembram do HTTP/3: meu navegador abriu o Nextcloud normalmente, enquanto o curl com uma entrada memorizada travou por 30 segundos. A resposta para o app de iOS agora está bem clara. Eu mesmo não o uso e só posso contar: em até 20 horas após o desligamento, 7 dispositivos iOS tinham voltado, sem intervenção, e o log que revisei não mostrou abortos nem erros de servidor. Nenhum dos dispositivos que estavam ativos nos três dias anteriores ao desligamento sumiu desde então. Outros sete dispositivos, que já estavam em silêncio há mais de três dias antes do desligamento, ainda não deram sinal; se são simplesmente pouco usados, o log não consegue mostrar. Alt-Svc: clear não foi necessário até agora. Vou ficar de olho até 12 de novembro.
A situação depois do rollout:
# All hosts
ingress_http3_enabled: false
- Os dois Nextclouds: HTTP/3 desligado. Arquivos de trabalho e sincronização dependem deles, e é exatamente ali que vivem as conexões longas.
- Blog: o HTTP/3 agora também está desligado aqui. No início eu queria mantê-lo com um limite de 5 minutos para workers antigos, porque as transferências ali são curtas. O teste foi bem: com um worker antigo criado de propósito, 8 de 55 requisições via HTTP/3 travaram. Depois de uns 5 minutos ele sumiu, e então 0 de 110 travaram. Um upload propositalmente lento foi cortado, como esperado. Mesmo assim, não me convenceu totalmente: o bug continua até o limite acabar, e no PR #503 outro operador relata, em uma versão mais antiga, um worker antigo que o limite não encerrou.
- O que vem a seguir: perguntei na Issue #1937 do nginx se está planejada uma solução sem os privilégios extras do
quic_bpf, e estou esperando a resposta. Também acompanho nos relatórios semanais de atualização se a F5 passa a suportar HTTP/3 oficialmente ou se o nginx resolve os reloads semquic_bpf. O interruptor continua: posso religar o HTTP/3 a qualquer momento.
O que eu levo disso:
- Oito execuções não provam nada. Um bug que atinge uma em cada nove execuções passa fácil. Meça a confiabilidade com muitas execuções, não só a velocidade.
- Confira a primeira explicação. Os 512 KiB encaixavam surpreendentemente bem e mesmo assim levaram para o lado errado. Só um segundo e um terceiro cliente mostraram isso.
- Meça de novo depois de cada reload. O bug não apareceu ao ligar, e sim durante um rollout posterior, perfeitamente normal.
- Um interruptor vale ouro. Como o HTTP/3 depende de um único interruptor por servidor, a retirada é pequena e pode ser revertida a qualquer momento.
- Novo não significa melhor. Sem um benefício mensurável, a confiabilidade pesa mais.
