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.

Resposta curta: 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.
Neste artigo
- O que o servidor cacheia sozinho, sem plugin nenhum
- A chave de cache não é só a URI
- As diretivas mínimas no vhost e o que cada valor decide
- Vary por cookie de sessão sem servir carrinho trocado
- TTL por contexto, porque um valor só serve mal os três
- Purgar de fora com X-LiteSpeed-Purge, no deploy ou no cron
- Como verificar hit, miss e TTFB com curl
- Onde o cache de página não resolve nada
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 aoCacheEnable public /no formato Apache): autoriza o servidor a *armazenar* a resposta.checkPublicCache 1(equivalente aoCacheLookup 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.
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 tragaSet-Cookie. Este é o interruptor que evita o pior acidente possível: oSet-Cookiefica 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: ignorarCache-Control: no-cachemandado pelo cliente. Sem isso, um F5 forçado (ou um bot mal-educado) atravessa o cache e vai direto ao PHP.ignoreRespCacheCtrl 0: respeitar oCache-Controlque 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:
<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.
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:
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:
# 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
// /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:
RewriteRule ^purge\.php - [E=Cache-Control:no-cache]
Chamando do deploy, do cron ou do webhook do CMS:
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:
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:
# 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: misssempre:checkPublicCachedesligado, ou a aplicação mandandoCache-Control: no-cachena resposta comignoreRespCacheCtrl 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 oCacheDisableou a regra de cookie chega depois do lookup na ordem do rewrite. - Página logada aparecendo para anônimo:
respCookieCacheligado, 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.