# HTTP/2 ativado e site em HTTP/1.1: as 4 causas

A sequência de curl que separa borda de origem, as quatro causas mais comuns e o texto pronto para explicar ao cliente por que o painel e o navegador discordam.

> são 4 camadas onde a negociação pode morrer: endereço sem TLS (sem ALPN), CDN ou proxy terminando o TLS na frente, HTTP/2 desligado no listener SSL em que o domínio está mapeado, ou leitura errada no DevTools. Dois curl com %{http_version} e %{remote_ip} isolam qual é.

João Rizzon · 2026-10-16 · Infraestrutura web

---

Você ligou o HTTP/2 no painel, reiniciou o serviço, e o cliente manda print do DevTools mostrando `http/1.1` na coluna Protocol. Antes de mexer em configuração de novo, vale separar onde a negociação morre. Na prática são quatro camadas possíveis, e cada uma tem um teste que a isola em segundos.

## Por que quem decide o HTTP/2 é o ALPN, não o painel do servidor

O HTTP/2 em navegador só acontece dentro de TLS, negociado por ALPN durante o handshake. O cliente envia a lista de protocolos que aceita (`h2`, `http/1.1`), o servidor escolhe um, e isso termina antes de qualquer byte de HTTP ser trocado.

Três consequências práticas:

- Se não há TLS, não há ALPN, e não há HTTP/2 para navegador. Testar `http://` devolve 1.1 em cenário de navegador. O `curl` pode negociar 2 em texto claro (h2c) quando ele mesmo pede o upgrade e o servidor aceita, mas nenhum navegador atual faz isso, então esse resultado não representa o que o cliente vê.
- Quem responde o ALPN é **quem termina o TLS**. Se tem Cloudflare, um balanceador ou um Nginx na frente, o servidor de origem nem participa dessa escolha.
- O painel mostra o estado do módulo no servidor. O navegador mostra o resultado da negociação na borda. As duas coisas podem divergir sem que nenhuma esteja mentindo.

A documentação oficial do LiteSpeed sobre troubleshooting de HTTP/2 lista justamente essa família de causas: protocolo desabilitado no listener ou no vhost, ausência de SSL no endereço testado e interferência de camada intermediária ([LiteSpeed: Troubleshooting HTTP/2](https://docs.litespeedtech.com/lsws/ts-http2/)).

## Dois curl que separam borda de origem

O teste base, para qualquer host:

```bash
curl -sI --http2 https://exemplo.com.br -o /dev/null -w '%{http_version} %{remote_ip}\n'
```

Saída de exemplo (fictícia, apenas para ilustrar o formato):

```
2 104.21.0.1
```

O `%{http_version}` diz o que foi negociado de fato; o `%{remote_ip}` diz com quem você falou. Esse segundo campo é o que a maioria dos diagnósticos esquece: se o IP não é o do seu servidor, você está medindo a CDN.

Para falar com a origem ignorando o DNS público, force a resolução:

```bash
curl -sI --http2 https://exemplo.com.br --resolve exemplo.com.br:443:203.0.113.10 \
  -o /dev/null -w '%{http_version}\n'
```

Troque `203.0.113.10` pelo IP real do servidor. Se aqui aparece `2` e no teste anterior apareceu `1.1`, o problema está na borda. Se aqui aparece `1.1`, o problema é seu.

E o teste de ALPN sem curl, útil quando você suspeita de certificado ou de SNI:

```bash
openssl s_client -connect exemplo.com.br:443 -servername exemplo.com.br -alpn h2 </dev/null 2>/dev/null | grep -i alpn
```

A linha esperada é `ALPN protocol: h2`. Se vier `No ALPN negotiated`, o servidor que terminou o TLS não ofereceu HTTP/2 para esse nome.

## Da saída do curl para a camada culpada

| Sintoma observado | Onde está o problema | Verificação |
|---|---|---||
| `--http2` em `http://` devolve 1.1 | Teste errado, não o servidor | Repetir em `https://` |
| `https://` devolve 1.1, `--resolve` na origem devolve 2 | Camada na frente (CDN, proxy, WAF) | Comparar `%{remote_ip}` dos dois testes |
| `--resolve` na origem devolve 1.1 | Servidor ou vhost | Checar listener e vhost do domínio |
| Um domínio devolve 2, outro no mesmo servidor devolve 1.1 | Configuração por vhost | Comparar os dois vhosts |
| `No ALPN negotiated` no openssl | TLS/SNI ou protocolo desligado no listener | Conferir certificado do SNI e listener |
| DevTools diz h2, curl diz 1.1 | curl sem suporte a HTTP/2, falta de `--http2` ou teste contra outro IP/porta | `curl -V | grep -i HTTP2` e comparar `%{remote_ip}` com o IP que o navegador usa |

## O endereço testado é http:// e não existe ALPN

É o falso negativo mais comum e o mais barato de eliminar. `curl --http2 http://exemplo.com.br` não faz upgrade para h2 em cenário de navegador: sem handshake TLS, sem ALPN. A documentação do LiteSpeed registra que HTTP/2 só é oferecido sobre SSL nesse contexto.

Teste os dois lados e compare:

```bash
for u in http://exemplo.com.br https://exemplo.com.br; do
  printf '%s -> ' "$u"
  curl -sI --http2 "$u" -o /dev/null -w '%{http_version}\n'
done
```

Se o `http://` devolve 1.1 e o `https://` devolve 2, está tudo certo e o diagnóstico acabou aqui.

Cuidado com redirect: se o teste em `https://` ainda devolve 1.1 mas o header traz um 301 para `www`, você está medindo a resposta do redirecionador, não a do site. Acrescente `-L` e teste o destino final.

## CDN, proxy ou WAF termina o TLS e responde o ALPN no lugar da origem

CDN, proxy reverso, WAF em nuvem, túnel, balanceador. Quem termina o TLS é quem decide o ALPN. O site pode servir HTTP/2 na borda e falar HTTP/1.1 com a origem, ou o contrário: origem em h2 e borda em 1.1 por configuração antiga.

Como confirmar sem acesso ao painel da CDN:

- Rode o teste com `%{remote_ip}` e compare com o IP do servidor.
- Olhe os headers de resposta: `cf-ray`, `x-cache`, `via`, `server` diferente do esperado indicam intermediário.
- Rode o teste `--resolve` apontando para a origem.

Se a borda devolve 1.1, a correção é no painel da borda, não no servidor. Em proxy reverso próprio (Nginx, HAProxy, Traefik), confira se o binário tem suporte compilado e como o protocolo está declarado: no Nginx 1.25.1 ou mais novo é a diretiva `http2 on;` dentro do `server` block (o antigo parâmetro no `listen` gera warning de depreciado), e em versões anteriores é `listen 443 ssl http2;`. Vale lembrar que o salto proxy para origem em HTTP/1.1 é normal e não afeta o que o navegador vê.

## O domínio está mapeado em um listener SSL sem HTTP/2

Quando um domínio responde em h2 e outro no mesmo servidor responde em 1.1, a configuração não é a mesma para os dois, mesmo parecendo. No LiteSpeed, a opção que liga o protocolo (`Enable SPDY/HTTP/2`) pertence ao **listener SSL**, não a uma diretiva de virtual host que sobrepõe o global. O vhost só se comporta de forma diferente quando está mapeado em outro listener, com IP ou porta própria, ou quando o handshake dele falha antes do ALPN.

Então, no cenário de dois domínios divergentes, verifique nesta ordem: em qual listener cada um está mapeado, se esse listener tem o protocolo habilitado, se o certificado apresentado para aquele SNI é válido, e se um dos dois está passando por CDN ou proxy e o outro não.

Triagem rápida para vários sites de uma vez, útil para agência com dezenas de hosts:

```bash
while read -r host; do
  v=$(curl -sI --http2 "https://$host" --max-time 10 -o /dev/null -w '%{http_version}' 2>/dev/null)
  printf '%-35s %s\n' "$host" "${v:-erro}"
done < dominios.txt
```

Coloque um domínio por linha em `dominios.txt`. A saída separa, em um passe, quem já está em h2 e quem ficou para trás, e vira um checklist de manutenção recorrente. Rode de novo depois de cada migração ou troca de certificado.

Outros pontos documentados que valem revisão quando a origem insiste em 1.1:

- Certificado inválido, expirado ou não correspondente ao SNI derruba o handshake antes do ALPN.
- Build ou versão do servidor sem suporte ao protocolo.
- Reinício efetivo: mudança em listener costuma exigir restart, não apenas reload de configuração.

## O teste está certo e a leitura do DevTools está errada

Antes de abrir chamado, elimine o erro de observação:

- No DevTools, a coluna **Protocol** não vem habilitada por padrão. Clique com o botão direito no cabeçalho da aba Network e marque Protocol. Procurar por outro campo gera conclusão errada.
- Recurso servido do cache do navegador pode exibir o protocolo da requisição antiga. Marque "Disable cache" e recarregue.
- Extensões de proxy, antivírus com inspeção TLS e VPN corporativa substituem o certificado e renegociam em HTTP/1.1 na máquina do cliente. Se o curl do servidor diz 2 e só o cliente diz 1.1, suspeite disso primeiro.
- Terceiros embutidos na página (pixel, chat, fonte externa) aparecem na mesma lista e podem estar em 1.1 sem relação alguma com o seu servidor. Filtre pelo domínio principal.

## Frases prontas para responder o cliente em cada camada

Frase pronta, para e-mail ou ticket, quando a borda é a responsável:

> **** O HTTP/2 está ativo no servidor. O que o navegador mostra é o protocolo negociado com o serviço que fica na frente do site (CDN/proxy), e é esse serviço que responde ao navegador. A alteração precisa ser feita no painel dele; no nosso lado já está habilitado e verificado.

Quando é o vhost do próprio site:

> **** A opção não estava habilitada no listener SSL em que este domínio está mapeado. Ajustamos e validamos: o site agora responde em HTTP/2.

E quando o problema é só na máquina do cliente:

> **** Nos nossos testes, feitos de fora da rede, o site responde em HTTP/2. O HTTP/1.1 que aparece aí costuma vir de antivírus, VPN ou extensão que inspeciona a conexão segura e refaz a negociação. Dá para confirmar abrindo o site em uma janela anônima, sem extensões, ou em outra rede.

## Checklist antes de fechar o chamado

- Testar em `https://`, nunca em `http://`.
- Registrar `%{http_version}` e `%{remote_ip}` na mesma saída.
- Repetir com `--resolve` contra o IP da origem.
- Confirmar ALPN com `openssl s_client -alpn h2`.
- Conferir em qual listener o domínio problemático está mapeado e comparar com um que funciona.
- Reiniciar o serviço, não só recarregar, após mudar listener.
- Rodar o laço sobre `dominios.txt` para fechar o inventário.
- Enviar ao cliente a frase correspondente à camada encontrada.

Fonte consultada para os cenários de servidor: [LiteSpeed: Troubleshooting HTTP/2](https://docs.litespeedtech.com/lsws/ts-http2/). Os valores de saída mostrados nos exemplos são ilustrativos, não medições.

