# Cache LiteSpeed no vhost sem plugin: 116 ms contra 1.786 ms

A chave de cache padrão, o vary por cookie de sessão, o TTL por contexto e a purga com X-LiteSpeed-Purge, do jeito de quem edita arquivo de vhost em vez de instalar plugin.

> Ligar enableCache e checkPublicCache no vhost do LiteSpeed baixou o TTFB mediano da mesma página WordPress de 1.786 ms para 116 ms, 15× de diferença, sem plugin de cache instalado. A camada de servidor entrega o hit sozinha: o plugin serve para invalidar e para declarar o vary, não para armazenar.

João Rizzon · 2026-09-05 · Infraestrutura web

---

## O que o servidor cacheia sozinho, sem plugin nenhum

O módulo de cache do LiteSpeed é parte do servidor, não do plugin. Ligado no vhost, ele guarda a resposta completa gerada pelo backend (lsphp, proxy, appserver) e passa a devolvê-la sem tocar no PHP na próxima requisição que bater na mesma chave. O plugin de aplicação não armazena nada: ele existe para dizer ao servidor **quando invalidar** e **por qual cookie variar**.

É por isso que a diferença aparece antes de qualquer otimização de aplicação. Na medição de setembro de 2026, a mesma página WordPress respondeu com TTFB mediano de **116 ms** servida do cache e **1.786 ms** quando o hit foi impedido, 15× de diferença, com 100 requisições e o miss forçado por query string única. Esses dois números são o piso e o teto do que essa camada entrega: o hit é o custo de ler o objeto do storage e escrever no socket, o miss é o custo real da sua stack.

Duas diretivas fazem coisas diferentes e são confundidas o tempo todo:

- **`enableCache 1`** (equivalente ao `CacheEnable public /` no formato Apache): autoriza o servidor a *armazenar* a resposta.
- **`checkPublicCache 1`** (equivalente ao `CacheLookup on`): autoriza o servidor a *procurar* uma entrada existente antes de mandar a requisição para o backend.

Só a primeira ligada, você enche o storage e nunca serve hit. Só a segunda, você serve o que a aplicação mandou cachear via cabeçalho e mais nada. As duas juntas é o cache de página de servidor puro.

**15×** diferença de TTFB mediano da mesma página WordPress com e sem cache de página (116 ms contra 1.786 ms) (n=100, setembro de 2026)

## A chave de cache não é só a URI

A entrada de cache é identificada por uma composição de campos. Não é só a URI.

| Componente | De onde vem | Como você mexe |
|---|---|---||
| Tipo | público ou privado | `enableCache` / `enablePrivateCache` |
| Host | cabeçalho `Host` da requisição | vhost / alias |
| URI | caminho antes do `?` | contexto, rewrite |
| Query string | tudo depois do `?` | `qsCache 0` para ignorar requisições com query |
| Vary | valores dos cookies declarados no vary | env `Cache-Vary`, `X-LiteSpeed-Vary` |

A consequência prática do quarto item é o motivo de a medição forçar miss por query string única: `/pagina?x=1` e `/pagina?x=2` são **duas entradas distintas**. Isso é ótimo para reproduzir um miss em laboratório e péssimo em produção, porque qualquer campanha com `?utm_source=`, `?fbclid=` ou `?gclid=` multiplica entradas do mesmo HTML e derruba a taxa de hit sem que ninguém perceba. Se o seu conteúdo não muda com a query, ou você normaliza os parâmetros de tracking no rewrite antes do lookup, ou aceita o storage inflado.

O tipo público e o privado são espaços separados. Público é servido para qualquer um que bata na chave. Privado é amarrado à sessão do cliente e nunca é compartilhado. Se você não tem uma disciplina de vary confiável, é mais seguro deixar `enablePrivateCache 0` e simplesmente não cachear o que é logado.

Sobre esquema (http vs https) e porta, não confie em suposição: monte a mesma URI nos dois esquemas e compare o `X-LiteSpeed-Cache` das respostas antes de assumir que compartilham ou não a mesma entrada.

## As diretivas mínimas no vhost e o que cada valor decide

No formato de configuração nativo (arquivo do vhost no LSWS Enterprise ou `httpd_config.conf` do OpenLiteSpeed), o bloco fica assim:

```
module cache {
  storagePath            /var/lscache/exemplo
  enableCache            1
  checkPublicCache       1
  expireInSeconds        300

  enablePrivateCache     0
  checkPrivateCache      0

  qsCache                1
  reqCookieCache         1
  respCookieCache        0

  ignoreReqCacheCtrl     1
  ignoreRespCacheCtrl    0

  maxCacheObjSize        10000000
  maxStaleAge            30

  ls_enabled             1
}
```

O que cada valor está decidindo:

- **`storagePath`**: diretório dos objetos. Um por vhost, com dono e permissão do usuário do vhost, senão você mistura sites no mesmo storage. Se apontar para tmpfs, dimensione a memória e lembre que o cache morre no reboot; em disco, o hit continua barato porque o objeto é lido inteiro em uma passada.
- **`respCookieCache 0`**: não armazenar resposta que traga `Set-Cookie`. Este é o interruptor que evita o pior acidente possível: o `Set-Cookie` fica armazenado junto da entrada de cache e é reenviado no cabeçalho da resposta ao visitante seguinte, que passa a carregar a sessão de outra pessoa. Não confie no default da sua build, declare explicitamente.
- **`reqCookieCache 1`**: permitir cachear requisição que *chega* com cookie. Precisa estar ligado, senão o primeiro cookie de analytics já derruba o cache para todo mundo. O controle correto de quem é anônimo e quem é logado é feito por regra de cookie, não aqui.
- **`ignoreReqCacheCtrl 1`**: ignorar `Cache-Control: no-cache` mandado pelo cliente. Sem isso, um F5 forçado (ou um bot mal-educado) atravessa o cache e vai direto ao PHP.
- **`ignoreRespCacheCtrl 0`**: respeitar o `Cache-Control` que a aplicação devolve. É assim que a aplicação consegue dizer "esta resposta não" sem você mexer em vhost.
- **`maxStaleAge 30`**: janela em que uma entrada expirada ainda é servida enquanto uma requisição revalida. Amortece a estampida no momento em que um TTL curto vence sob carga.

No LSWS Enterprise, que lê `.htaccess`, o mesmo par mínimo pode ficar por diretório:

```apache
<IfModule LiteSpeed>
  CacheLookup on
  CacheEnable public /
  CacheDisable public /wp-admin/
  CacheDisable public /wp-login.php
  CacheDisable public /wp-json/
</IfModule>
```

O OpenLiteSpeed não lê `.htaccess`: as mesmas exclusões viram contexto ou regra de rewrite no vhost.

Requisição não-GET/HEAD não é servida do cache. Um `POST` para uma URI cacheada passa direto para o backend; o que você precisa garantir é a invalidação depois dele.

## Vary por cookie de sessão sem servir carrinho trocado

Sem isso, você serve carrinho de um para outro. Existem dois caminhos, e eles resolvem problemas diferentes.

### Barrar o cache quando o cookie significa página única

Se a presença do cookie significa "esta pessoa vê uma página única", não tente variar: desligue o cache para ela.

```apache
RewriteEngine On
RewriteCond %{HTTP_COOKIE} (^|;\ *)wordpress_logged_in_ [NC,OR]
RewriteCond %{HTTP_COOKIE} (^|;\ *)wp-postpass_ [NC,OR]
RewriteCond %{HTTP_COOKIE} (^|;\ *)woocommerce_items_in_cart [NC,OR]
RewriteCond %{HTTP_COOKIE} (^|;\ *)wp_woocommerce_session_ [NC]
RewriteRule .* - [E=Cache-Control:no-cache]
```

A variável de ambiente `Cache-Control` interpretada pelo LiteSpeed no rewrite é o mesmo mecanismo usado para `max-age`, `private` e `no-cache`. Aqui ela diz: esta requisição não faz lookup nem armazena.

### Variar quando o número de variantes é finito

Quando o cookie tem poucos valores possíveis (moeda, idioma, região, teste A/B), declare o nome dele no vary e o servidor passa a incluir o valor na chave:

```apache
RewriteRule .* - [E="Cache-Vary:moeda,idioma"]
```

A aplicação também pode declarar isso na resposta, com `X-LiteSpeed-Vary`, o que é útil quando quem sabe a regra é o código e não o vhost.

A conta a fazer antes: cada valor distinto multiplica as entradas daquela URI. Dois cookies com três valores cada já são nove variantes por página. Cookie de sessão (`PHPSESSID`, `wp_woocommerce_session_`) tem cardinalidade praticamente infinita, então ele **nunca** entra no vary público, entra na lista de barrar.

| Cookie | Tratamento |
|---|---||
| `wordpress_logged_in_*` | barrar |
| `wp-postpass_*` | barrar |
| `wp_woocommerce_session_*` | barrar |
| `woocommerce_items_in_cart` | barrar |
| `comment_author_*` | barrar |
| `PHPSESSID` genérico | barrar |
| moeda, idioma, país | variar |
| bucket de teste A/B | variar |

## TTL por contexto, porque um valor só serve mal os três

TTL único para o site inteiro só funciona se todas as URIs mudarem no mesmo ritmo, o que não acontece. A home muda a cada publicação, o post de 2019 não muda nunca, e o endpoint de estoque não pode ficar 5 minutos velho. Um valor só serve mal os três: curto demais para o post, longo demais para o estoque.

O valor global vem de `expireInSeconds`. Por trecho, a forma mais direta é a variável de ambiente no rewrite:

```apache
# padrão do vhost: 5 minutos
RewriteRule .* - [E=Cache-Control:max-age=300]

# arquivo de post antigo: 1 dia
RewriteRule ^\d{4}/\d{2}/ - [E=Cache-Control:max-age=86400]

# listagem que muda com frequência: 60 s
RewriteRule ^(categoria|tag)/ - [E=Cache-Control:max-age=60]

# endpoint de estoque: fora do cache
RewriteRule ^api/estoque - [E=Cache-Control:no-cache]
```

No OpenLiteSpeed, o mesmo efeito pode vir de um bloco `module cache` dentro de um `context`, com `enableCache` e `expireInSeconds` próprios daquele caminho.

| Classe de URI | TTL sugerido | Invalidação |
|---|---|---||
| Home e listagens | 60 s | purga em publicação |
| Post ou página estável | 86400 s | purga na edição |
| Busca interna (`?s=`) | não cachear | não se aplica |
| Carrinho, checkout, conta | não cachear | não se aplica |
| Feed RSS, sitemap | 3600 s | purga em publicação |
| API pública de leitura | 30 s a 60 s | TTL curto, sem purga |

Regra de bolso para escolher o TTL: se você tem purga confiável, TTL longo e purga no evento. Se você não tem, TTL curto e conviva com um miss periódico de 1.786 ms para o azarado que pegou a expiração.

## Purgar de fora com X-LiteSpeed-Purge, no deploy ou no cron

A purga não é uma requisição especial que o servidor entende sozinho. Ela é um **cabeçalho de resposta**: o backend responde `X-LiteSpeed-Purge` e o servidor apaga as entradas indicadas ao processar aquela resposta. Purgar "de fora" é, portanto, chamar uma URI da sua aplicação que devolve esse cabeçalho.

Um endpoint mínimo, protegido por token e por allowlist de origem, fora do cache:

```php
<?php
// /purge.php
$permitidos = ['203.0.113.10', '198.51.100.7']; // runner de deploy, host do cron

$token = getenv('PURGE_TOKEN');
if ($token === false || !hash_equals($token, $_GET['t'] ?? '')) {
    http_response_code(403);
    exit;
}

if (!in_array($_SERVER['REMOTE_ADDR'] ?? '', $permitidos, true)) {
    http_response_code(403);
    exit;
}

$alvo = $_GET['uri'] ?? '*';
header('X-LiteSpeed-Purge: ' . $alvo);
header('Cache-Control: no-cache');
echo "purge: $alvo\n";
```

Sobre o `REMOTE_ADDR`: se houver CDN ou proxy reverso na frente, ele é o IP do proxy e a allowlist não filtra nada. Nesse caso, ou você libera a porta só na rede interna, ou usa o IP real que o LiteSpeed já resolve com `useIpInProxyHeader` ligado apenas para os IPs do seu proxy. Ler `X-Forwarded-For` direto no PHP, sem isso, é aceitar um cabeçalho que o cliente escolhe.

Mantenha o próprio endpoint fora do cache, senão a segunda chamada é servida do storage e nenhum cabeçalho chega ao servidor:

```apache
RewriteRule ^purge\.php - [E=Cache-Control:no-cache]
```

Chamando do deploy, do cron ou do webhook do CMS:

```bash
curl -s "https://exemplo.com.br/purge.php?t=$PURGE_TOKEN&uri=/blog/post-x"
curl -s "https://exemplo.com.br/purge.php?t=$PURGE_TOKEN&uri=*"
```

Valores aceitos no cabeçalho, do mais cirúrgico ao mais bruto:

| Valor | Efeito |
|---|---||
| `/uri/especifica` | apaga aquela URI |
| `tag=nome` | apaga tudo marcado com a tag |
| `*` | apaga o cache inteiro do vhost |

Para usar tag, a resposta que cria a entrada precisa carregar `X-LiteSpeed-Tag` com os identificadores dela (por exemplo, o ID do post e o da categoria). Aí uma edição purga as dezenas de listagens onde aquele post aparece sem você enumerar URI por URI.

Dois detalhes que só aparecem em produção: purgar `*` a cada deploy transforma a primeira visita de cada página em um miss, e cada um desses miss custa o caminho completo pela aplicação; e purga por URI não é garantia de alcançar todas as variantes de query string daquela página, porque cada query distinta é uma chave distinta. Teste o seu caso com `curl -I` antes de confiar.

O último recurso, quando algo ficou preso, é apagar o conteúdo do `storagePath` do vhost. É seguro (o servidor recria), mas é o equivalente a purgar tudo.

## Como verificar hit, miss e TTFB com curl

O servidor devolve `X-LiteSpeed-Cache` nas respostas que passam pelo módulo. Comece por ele:

```bash
curl -sI https://exemplo.com.br/ | grep -i '^x-litespeed'
```

Para medir o que interessa, `time_starttransfer` do curl, que é o tempo até o primeiro byte do corpo, incluindo DNS, conexão, TLS e o processamento no servidor. São as mesmas 100 amostras por série usadas na medição citada aqui, para que o procedimento seja o mesmo:

```bash
# 100 amostras do hit
for i in $(seq 1 100); do
  curl -so /dev/null -w '%{time_starttransfer}\n' https://exemplo.com.br/
done | sort -n | sed -n '50p'

# 100 amostras do miss, forçado por query string única
for i in $(seq 1 100); do
  curl -so /dev/null -w '%{time_starttransfer}\n' \
    "https://exemplo.com.br/?cachebust=$(date +%s%N)"
done | sort -n | sed -n '50p'
```

O `sed -n '50p'` sobre 100 valores ordenados pega a mediana inferior, que é o número resistente ao outlier de rede. Rode do mesmo lugar as duas séries, no mesmo intervalo, senão você está medindo o link e não o servidor.

Os modos de falha que essa checagem com `curl -I` expõe, e o que olhar em cada um:

- **`X-LiteSpeed-Cache: miss` sempre**: `checkPublicCache` desligado, ou a aplicação mandando `Cache-Control: no-cache` na resposta com `ignoreRespCacheCtrl 0`, ou um cookie que casa com a sua regra de barrar sendo enviado pelo curl.
- **Hit em URI que não podia**: `/wp-admin`, `/wp-json`, checkout. Falta o `CacheDisable` ou a regra de cookie chega depois do lookup na ordem do rewrite.
- **Página logada aparecendo para anônimo**: `respCookieCache` ligado, ou vary ausente, ou entrada criada antes de você escrever a regra e ainda dentro do TTL. Purgue `*` depois de mexer em vary.
- **Taxa de hit baixa com storage crescendo**: query string de campanha criando uma entrada por clique.
- **Conteúdo velho depois do deploy**: nenhuma purga acontecendo, porque o endpoint de purga está ele próprio cacheado.

## Onde o cache de página não resolve nada

O custo do hit não depende da aplicação: o servidor lê o objeto e escreve no socket, sem executar PHP. Mas o número absoluto depende do resto. Os 116 ms medidos aqui valem para aquela página, daquele ponto de origem, com aquele payload. Mude o tamanho do HTML, a distância até o cliente, o handshake TLS (sessão nova contra retomada) ou o protocolo, e o valor muda junto, sem que o cache tenha ficado melhor ou pior. Meça o seu.

O que não muda é o outro lado do número. Se o seu miss é 1.786 ms, todo visitante que cai fora do cache paga isso: o logado, o carrinho, o checkout, o admin, o cron, o bot que entra com query string nova. Cache de página não encobre nada disso.

Antes de trocar de plano por causa de TTFB, meça o miss isolado e olhe o que ele está fazendo. Log de consulta lenta do MySQL com `long_query_time` baixo por uma hora, ou um profile do PHP na requisição, costumam apontar uma query sem índice ou uma chamada HTTP externa síncrona dentro do render. Corrigir isso baixa o miss para todo mundo, inclusive para quem nunca vai ver um hit. O cache de servidor você liga depois, e ele passa a ser ganho de escala em vez de curativo.

A ordem que funciona: primeiro medir o miss, depois ligar `enableCache` e `checkPublicCache`, depois escrever as regras de cookie, depois escolher TTL por contexto e só então automatizar a purga. Ligar tudo de uma vez, em produção, é como se descobre da pior forma que a página do carrinho estava no cache público.

---

## Como medimos

100 requisições HTTPS à mesma página WordPress em um servidor LiteSpeed da Napoleon, feitas de um VPS externo: 50 aproveitando o cache de página (x-litespeed-cache: hit) e 50 forçando a geração pelo PHP com query string única (miss). TTFB medido com curl (time_starttransfer); medianas: 115,6 ms com cache, 1.785,8 ms sem.
